A unit may also refer to a single component in React. For example, we can test that when the input has changed, that the state of the component is updated in an expected way; or for controlled components, that the right callback is called with the correct parameters
Table of Contents for
Building Enterprise JavaScript Applications
Building Enterprise JavaScript Applications
Published by
Packt Publishing, 2018
- Building Enterprise JavaScript Applications
- Title Page
- Copyright and Credits
- Building Enterprise JavaScript Applications
- Dedication
- Packt Upsell
- Why subscribe?
- PacktPub.com
- Contributors
- About the author
- About the reviewer
- Packt is searching for authors like you
- Table of Contents
- Preface
- Who this book is for
- What this book covers
- Section 1 – Theory and practice
- Section 2 – Developing our backend API
- Section 3 – Developing our frontend UI
- Section 4 – Infrastructure and automation
- Section 5 – Important JavaScript concepts and syntax
- What is not covered
- To get the most out of this book
- Download the example code files
- Conventions used
- Get in touch
- Reviews
- The Importance of Good Code
- Technical debt
- What is technical debt?
- Causes of technical debt
- The debt spiral
- Consequences of technical debt
- Technical debt leads to low morale
- Consequences of low morale
- Repaying technical debt through refactoring
- Preventing technical debt
- Informing the decision makers
- The triple constraint
- The fallacy of the triple constraint
- Refuse to develop
- Don't be a hero
- Defining processes
- Test-Driven Development
- Understanding the TDD process
- Fixing bugs
- Benefits of TDD
- Avoiding manual tests
- Tests as specification
- Tests as documentation
- Short development cycles
- Difficulties with TDD adoption
- When not to use TDD
- Summary
- The State of JavaScript
- Evolution of the web application
- Just-in-time (JIT) compilers
- Single page applications (SPAs)
- Isomorphic JavaScript applications
- Benefits of Node.js
- Context switching
- Switching between projects
- Switching between languages
- The business perspective
- Shared code
- Summary
- Managing Version History with Git
- Setting up Git
- Creating a new repository
- Configuring Git
- Configuring a user
- Learning the basics
- Committing to history
- Understanding file states in Git
- The three tracked states
- Staging our changes
- Quick recap
- Branching and merging
- Git branches
- Branching models
- The Driessen model
- Creating a development branch
- Creating feature branches
- Naming sub-branches
- Merging branches
- Examining more realistic examples
- Keeping the dev Branch Bug-Free
- Keeping our history clean
- Keeping our history clean with git rebase
- Using merge and rebase together
- Releasing code
- Semantic versioning
- Creating a release branch
- Tagging releases
- Hotfixes
- Working with others
- Creating a remote repository
- Pulling and pushing
- Cloning a repository
- Conducting peer review through pull requests
- Summary
- Setting Up Development Tools
- What is Node.js?
- Terminology
- Modules
- The dawn of modules
- The birth of Node.js modules
- Adoption of the CommonJS standard
- Fulfilling the encapsulation requirement
- Standardizing module formats
- Installing Node
- Using nvm to install Node
- Documenting Node versions
- Starting projects with npm
- Using yarn instead of npm
- Package version locking
- Offline cache
- Speed
- Installing yarn
- Getting familiar with the yarn CLI
- npm and yarn, together
- Creating an HTTP server
- Our HTTP server in detail
- Transpiling ES6 with Babel
- Babel is a transpiler...and more!
- Different faces of Babel
- @babel/cli
- @babel/register
- Using @babel/register for tests
- @babel/node
- @babel/core
- @babel/polyfill
- Adding Babel CLI and polyfill
- Using Babel CLI to transpile our code
- Plugins and presets
- The env preset
- Separating source and distribution code
- Importing the Babel polyfill
- Consolidating commands with npm scripts
- Ensuring cross-platform compatibility
- Automating development using nodemon
- Linting with ESLint
- Installing ESLint
- Linting our code
- Adding lint script to package.json
- Installing the ESLint extension
- Adding pre-commit hooks
- Committing our code into Git
- Using .gitignore to ignore files
- Summary
- Writing End-to-End Tests
- Understanding different types of test
- Structuring our test suite with the testing pyramid
- When implementing a new feature, write your E2E tests first
- Following a TDD workflow
- Gathering business requirements
- Formalizing requirements through documentation
- Refining requirements into specification
- Writing tests as specification
- Test-driven development
- Writing manual tests
- Exploratory testing
- Maintenance
- Gathering requirements
- Setting Up E2E tests with Cucumber
- Features, scenarios, and steps
- Gherkin keywords
- Specifying our feature
- Writing our first scenario
- Laying out our step definitions
- Running our scenarios
- Implementing step definitions
- Calling our endpoint
- Asserting results
- Using a debugger for Node.js debugging
- Using Chrome DevTools
- Using ndb
- Using the Visual Studio Code debugger
- Retaining line numbers
- Examining the req object
- Making work-in-progress (WIP) commits
- Asserting the correct response status code
- You ain't gonna need it (YAGNI)
- Asserting the correct response payload
- Asserting the correct response payload content
- Refactoring
- Isolating contexts for each scenario
- Making failure more informative
- Removing hardcoded values
- Validating data type
- Refactoring our tests
- Using scenario outlines
- Combining duplicate step definitions
- Refactoring our application
- Choosing a framework
- Migrating our API to Express
- (Re)defining routes
- Using body-parser middleware
- Run E2E test
- Moving common logic into middleware
- Validating our payload
- Checking for required fields
- Checking property type
- Checking the payload property's format
- Refactoring our step definitions
- Testing the success scenario
- Summary
- Storing Data in Elasticsearch
- Introduction to Elasticsearch
- Elasticsearch versus other distributed document store
- Installing Java and Elasticsearch
- Installing Java
- Installing and starting Elasticsearch
- Understanding key concepts in Elasticsearch
- Elasticsearch is a JSON document store
- Document vs. relationship data storage
- Understanding indices, types, documents, and versions
- Querying Elasticsearch from E2E tests
- Indexing documents to Elasticsearch
- Cleaning up after our tests
- Deleting our test user
- Improving our testing experience
- Running tests in a test database
- Separating development and testing servers
- Making a standalone E2E test script
- The shebang interpreter directive
- Ensuring Elasticsearch is running
- Running the test API server in the background
- Checking our API server is ready
- Checking API status using netstat/ss
- Cleaning up the background process
- Running our tests
- Summary
- Modularizing Our Code
- Modularizing our code
- Modularizing our middleware
- Modularizing our request handlers
- The single responsibility principle
- Decoupling our validation logic
- Creating the ValidationError interface
- Modularizing our validation logic
- Creating engines
- Adding a user profile
- Writing a specification as a test
- Schema-based validation
- Types of schema
- Picking an object schema and validation library
- Interoperability
- Expressiveness
- Creating our profile schema
- Rejecting additional properties
- Dynamic mapping in Elasticsearch
- Adding specificity to a sub-schema
- Adding a title and description
- Specifying a meta-schema
- Specifying a unique ID
- Creating a schema for the Create User request payload
- Picking a JSON Schema validation library
- Validating against JSON Schema with Ajv
- Generating validation error messages
- Generalizing functions
- Updating the npm build script
- Testing the success scenario
- Resetting our test index
- Summary
- Writing Unit/Integration Tests
- Picking a testing framework
- Installing Mocha
- Structuring our test files
- Writing our first unit test
- Describing the expected behavior
- Overriding ESLint for test files
- Understanding arrow functions in Mocha
- Specifying ESLint environments
- Running our unit tests
- Running unit tests as an npm script
- Completing our first unit test suite
- Unit testing ValidationError
- Unit testing middleware
- Asserting deep equality
- Asserting function calls with spies
- Simulating behavior with stubs
- Testing all middleware functions
- Unit testing the request handler
- Stubbing create
- Dependency injection
- Monkey patching
- Dependency injection versus monkey patching
- Modularity
- Readability
- Reliance on third-party tools
- Following the dependency injection pattern
- Promises and Mocha
- Dealing with rejected promises
- Completing the unit tests
- Unit testing our engine
- Integration testing our engine
- Adding test coverage
- Reading a test coverage report
- Improving test coverage
- Code coverage versus test quality
- You don't have to test everything, all the time
- Unifying test coverage
- Ignoring files
- Finishing up
- Summary
- Designing Our API
- What it means to be RESTful
- What is REST?
- What REST is not
- Should my API be RESTful?
- Designing our API
- Consistent
- Common consistency
- Sending the correct HTTP status code
- Using HTTP methods
- Using ISO formats
- Local consistency
- Naming convention
- Consistent data exchange format
- Error response payload
- Transversal consistency
- Domain consistency
- Perennial consistency
- Breaking changes in APIs
- Future-proofing your URL
- Future-proofing your data structure
- Versioning
- Intuitive
- URLs for humans
- Favor verbosity and explicitness
- Keep It Simple Stupid (KISS)
- Completing our API
- Summary
- Deploying Our Application on a VPS
- Obtaining an IP address
- Managed DNS
- Setting up a Virtual Private Server (VPS)
- Creating a VPS instance
- Choosing an image
- Choosing a size
- Picking a data center region
- Selecting additional options
- Naming your server
- Connecting to the VPS
- Setting up user accounts
- Creating a new user
- Adding a user to the sudo group
- Setting up public key authentication
- Checking for existing SSH key(s)
- Creating an SSH key
- Adding the SSH key to the remote server
- Using ssh-copy-id
- Providing extra security
- Disable password-based authentication
- Disable root login
- Firewall
- Configuring the time zone
- Running our API
- Keeping our API alive with PM2
- Killing a process
- Keeping PM2 alive
- Running our API on port 80
- Privileged ports
- Possible solutions
- Running as root
- De-escalating privileges
- Setting capabilities
- Using authbind
- Using iptables
- Using reverse proxy
- What's a proxy? What's a reverse proxy?
- Setting up NGINX
- Configuring NGINX
- Understanding NGINX's configuration file
- Configuring the HTTP module
- Splitting nginx.conf into multiple files
- From IP to domain
- Buying a domain
- Understanding DNS
- Updating the domain nameserver
- Building our zone file
- NS records
- A and AAAA
- Start of Authority (SOA)
- Updating NGINX
- Summary
- Continuous Integration
- Continuous Integration (CI)
- Picking a CI server
- Integrating with Travis CI
- Configuring Travis CI
- Specifying the language
- Setting up databases
- Setting environment variables
- Activating our project
- Examining Travis CI results
- Continuous Integration with Jenkins
- Introduction to Jenkins
- Freestyle projects
- Pipeline
- Setting up a new Jenkins server
- Creating the jenkins user
- Configuring time
- Installing Java
- Installing Jenkins
- Installing NGINX as a reverse proxy
- Configuring the firewall
- Updating our DNS records
- Configuring Jenkins
- Composing a Jenkinsfile
- The Pipeline DSL syntax
- Declarative versus scripted pipelines
- The declarative pipeline
- The scripted pipeline
- Setting up the environment
- Installing Docker
- Integration with GitHub
- Providing access to the repository
- The Personal Access (OAuth) Token
- Using the GitHub plugin
- Setting up GitHub service hooks manually
- Creating a new folder
- Creating a new pipeline
- Running the first build
- Summary
- Security – Authentication and Authorization
- What is Authentication?
- Introduction to password-based authentication
- Hashing passwords
- Cryptographic hash functions
- Picking a cryptographic hashing algorithm
- Hash stretching
- Hash stretching algorithms
- Preventing brute-force attacks against a single user
- Protecting against brute-force attacks
- Reverse lookup table attacks
- Protecting against reverse lookup table attacks
- Implementing password-base authentication
- Updating existing E2E tests
- Generating a random digest
- Picking a bcrypt library
- Using the bcryptjs library
- Validating a digest
- Updating an existing implementation
- Retrieving the salt
- Implementing the Retrieve Salt endpoint
- Implementing a Retrieve Salt engine
- Generating a salt for non-existent users
- Writing E2E tests
- Implementation
- Login
- Writing tests
- Implementing Login
- Keeping users authenticated
- JSON web tokens (JWTs)
- Anatomy of a JWT
- Header
- Payload and claims
- Registered claim names
- Public claim names
- Private claim names
- Example claim
- Signature
- Asymmetric signature generation
- Symmetric signature generation
- Picking an algorithm
- A note on encryption
- Terminology and summary
- Responding with a token
- Adding E2E Tests
- Implementation
- Multiline environment variables
- Generating the token
- Attaching the token
- HTTP cookies
- Cross-Site Scripting (XSS)
- Cross-Site Request Forgery (XSRF)
- HTTP headers
- The Authorization header
- Writing tests
- Features and scenarios
- Implementation step definitions
- Verifying the digest in the request
- Next steps
- Preventing man-in-the-middle (MITM) attacks
- Encrypting digests
- Block cipher
- Exploring the Secure Remote Password (SRP) protocol
- Summary
- Documenting Our API
- Overview of OpenAPI and Swagger
- Picking an API specification language
- Swagger vs OpenAPI
- Swagger Toolchain
- Swagger Editor
- Swagger UI
- Swagger Inspector
- Swagger codegen
- Defining an API specification with OpenAPI
- Learning YAML
- An overview of the root fields
- Specifying the GET /salt endpoint
- Specifying parameters
- Specifying responses
- Specifying the Create User endpoint
- Specifying the request body
- Defining common components
- Specifying the Retrieve User endpoint
- Specifying the Replace Profile endpoint
- Specifying the rest of the endpoints
- Generating documentation with Swagger UI
- Adding the Swagger UI to our repository
- Using our specification in the Swagger UI
- Exposing swagger.yaml from our API
- Enabling CORS
- Same-origin policy
- Cross-Origin Resource Sharing (CORS)
- Final touches
- Replacing the specification URL
- Removing the header
- Deployment
- Summary
- Creating UI with React
- Picking a front-end framework/library
- Vanilla JavaScript vs. frameworks
- Choosing a framework/library
- Popularity/community
- Features
- Virtual DOM
- JSX
- Post-React
- Flexibility
- Performance
- Cross-platform
- Hybrid applications with Ionic
- Native UI with React Native and Weex
- Learning curve
- Conclusion
- Getting started with React
- What is React?
- Components
- Virtual DOM
- How Virtual DOM improves performance
- React is declarative
- React summary
- Starting a new repository
- Adding some boilerplate
- Creating our first component
- JSX
- Transpiling JSX
- Defining React components
- Functional and class components
- Pure components
- Maintaining the state and listening for events
- Handling events
- setState and immutability
- Rendering the state
- Submitting forms
- Uncontrolled form elements
- Resolving CORS issues
- Disabling the Button component
- Controlled form elements
- Modularizing React
- Client-side modules
- Module bundling
- Browserify
- Webpack
- Rollup
- Parcel
- Asynchronous module loading
- AMD and Require.js
- Universal Module Definition
- SystemJS and the Loader specification
- jspm
- Module bundler versus module loader
- HTTP/2
- Webpack
- Modularizing our components
- Entry/output
- Loaders
- Plugins
- Copying files
- Final steps
- Summary
- E2E Testing in React
- Testing strategies
- Automated UI testing
- Unit testing
- Logical units
- Component units
- Browser testing
- Writing E2E tests with Gherkin, Cucumber, and Selenium
- Adding test script
- Specifying a feature
- Adding IDs to elements
- Selenium
- WebDriver API
- Using Selenium WebDriver
- Headless browsers
- Browser drivers
- Setup and teardown
- Implementing step definitions
- Navigating to a page
- Typing into input
- Asserting a result
- Running the tests
- Adding multiple testing browsers
- Running our backend API
- Dynamic string substitution with Webpack
- Serving the API from a submodule
- Defining the happy scenario
- Generating random data
- Making step definitions more generic
- Clicking
- Waiting
- Render components based on state
- Routing with React Router
- Basics
- Router
- Route matching
- Supporting the History API
- Navigation
- TDD
- Login
- Writing tests
- Implementing Login
- Over to you
- Summary
- Managing States with Redux
- State management tools
- Redux
- MobX
- Redux versus MobX
- Converting to Redux
- Creating the store
- Lifting the state up
- Dispatching actions
- Updating the state with the Reducer
- Connecting with React Redux
- Wrapping with the Provider component
- Connecting to the Redux store
- mapStateToProps
- mapDispatchToProps
- Decoupling Redux from components
- Summary
- Migrating to Docker
- Problems with manual deployment
- Introduction to Docker
- What are containers?
- Workflow
- How does Docker solve our issues?
- Mechanics of Docker
- What is a Docker container?
- Control groups
- Namespaces
- LXC and Docker
- Virtual Machines
- Containers versus Virtual Machines
- What is a Docker image?
- Images are layered
- Running a container
- Setting up the Docker Toolchain
- Adding the Docker package repository
- Installing Docker
- Docker Engine, Daemon, and Client
- Running Elasticsearch on Docker
- Running a container
- Understanding the docker run option
- Identifying a container by name
- Setting environment variables
- Running as daemon
- Network port mapping
- 0.0.0.0
- Updating our test script
- Dockerizing our backend API
- Overview of a Dockerfile
- Writing our Dockerfile
- Picking a base image
- Copying project files
- Building our application
- Specifying the executable
- Building our image
- Running our image
- Persisting data
- Following best practices
- Shell versus exec forms
- Allowing Unix signaling
- Running as a non-root user
- Taking advantage of the cache
- Caveats
- Using a lighter image
- Removing obsolete files
- Multi-stage builds
- Security
- Summary
- Robust Infrastructure with Kubernetes
- High availability
- Measuring availability
- Following the industry standard
- Eliminating single points of failure (SPOF)
- Load balancing versus failover
- Load balancing
- DNS load balancing
- Layer 4/7 load balancers
- Layer 4 load balancers
- Layer 7 load balancing
- High reliability
- Testing for reliability
- High throughput
- High scalability
- Clusters and microservices
- Microservices
- Clusters
- Cluster management
- Cluster-level tools
- Discovery service
- Scheduler
- Global configuration store
- Provisioning tools
- Picking a cluster management tool
- Control Planes and components
- Master components
- kube-apiserver
- kube-control-manager
- Node components
- Container runtime
- kubelet
- kube-proxy
- Kubernetes objects
- The four basic objects
- High-level objects
- Controllers
- Setting up the local development environment
- Checking hardware requirements
- Cleaning our environment
- Disabling swap memory
- Installing kubectl
- Installing Minikube
- Installing a Hypervisor or Docker Machine
- Creating our cluster
- Setting environment variables for the local cluster
- Running minikube start
- Updating the context
- Resetting the cluster
- Creating our first Pod
- Running Pods with kubelet
- Running Pods with kubectl run
- Understanding high-level Kubernetes objects
- Declarative over imperative
- Deleting deployment
- Creating a deployment manifest
- A note on labels
- Running pods declaratively with kubectl apply
- Kubernetes Object management hierarchy
- Configuring Elasticsearch cluster
- Networking for distributed databases
- Configuring Elasticsearch's Zen discovery
- Attaching hostnames to Pods
- Working with StatefulSets
- Ordinal index
- Working with services
- Linking StatefulSet to a service
- Updating Zen Discovery configuration
- Validating Zen Discovery
- Deploying on cloud provider
- Creating a new remote cluster
- Switching contexts
- Configuring nodes for Elasticsearch
- Running commands on multiple servers
- Using pssh
- Using init containers
- Running the Elasticsearch service
- Validating Zen Discovery on the remote cluster
- Persisting data
- Introducing Kubernetes Volumes
- Defining Volumes
- Problems with manually-managed Volumes
- Introducing PersistentVolume (PV)
- Consuming PVs with PersistentVolumeClaim (PVC)
- Deleting a PersistentVolumeClaim
- Deleting a PersistentVolume
- Problems with manually provisioning PersistentVolume
- Dynamic volume provisioning with StorageClass
- Defining a StorageClass
- Using the csi-digitalocean provisioner
- Provisioning PersistentVolume to StatefulSet
- Configuring permissions on a bind-mounted directory
- Visualizing Kubernetes Objects using the Web UI Dashboard
- Launching the Web UI Dashboard locally
- Launching the Web UI Dashboard on a remote cluster
- Deploying the backend API
- Publishing our image to Docker Hub
- Creating a Deployment
- Discovering Services using kube-dns/CoreDNS
- Running Our backend Deployment
- Creating a backend Service
- Exposing services through Ingress
- Deploying the NGINX Ingress Controller
- Deploying the Ingress resource
- Updating DNS records
- Summary
- Other Books You May Enjoy
- Leave a review - let other readers know what you think