Testing

1. All the code
2. From the tested code all the way down the stack
3. Some segment of the code in the middle of the stack
4. Only the method/function under test

Run all the code

• End to End <-- For clarity
• Integration
• Functional
• Situational
• Acceptance

Run from the tested code all the way down the stack
and segments of code in the middle of the stack

• Integration <-- For clarity
• Functional
• Unit

Run only the code under test (one method or function)

• Unit <-- For clarity

End to End Tests - The Ugly

What's their purpose?

• Show that your software actually works.
• Where you find logic errors and high level mistakes in your code.
• ONLY tests that will actually find bugs in your code base.
• Don't change often
• Often are very similar, making them easy to write

How does that look on the stack?

Integration Tests - The Bad

What's their purpose?

• Help you write code
• You can see that new code really works on the stack
• They test how units work together...
• You don't have to test to the bottom of the stack!

How does that look on the stack?

Unit Tests - The good

What's their purpose?

• Changes to the code base cause them to fail
  • Mutation Testing
• Any and all possible inputs and outputs are tested
  • Trust Stack
• You no longer need to look at this code, as long as the tests pass
  • This test and all end to end tests

How does that look on the stack?

Examples Please

End to End

should('Write files to S3 when the user clicks save') do
  # Given: the user has some files to save
  file_path = 'test'
  user_files = [{
    name: file_path,
    data: 'data'
  }]
  visit 'pages/s3'
  page.files = user_files

  # When: the user clicks save and we check S3
  page.button({ id: 'save' }).click
  s3 = S3.new
  result = s3.read(file_path)

  # Then: we should see the files are on S3
  assert_false(result == nil)
end
            

Integration

should('result in the S3 bucket files being read in chunks based ' +
  'on the selected chunk size, ignoring empty files') do
  # Given: a file on S3 with more than 5 bytes of data
  #   and less than 10 bytes, a file on S3 with no data,
  #   and an S3Implementation object with the chunk size set to 5 bytes
  s3 = S3.new
  file_path = 'test'
  s3.write(file_path + "/data", 'some data')
  s3.write(file_path + "/nodata", '')

  s3_implementation = S3Implementation.new(file_path)
  s3_implementation.chunk_size = 5

  # When: we iterate over the data with the s3_implementation object
  count = 0
  s3_implementation.each do |chunk|
    count += 1
  end

  # Then: we should see 2 chunks: 2 for the file with more than 5 bytes,
  #   and none for the empty file
  assert_equal(2, count)
end
            

Unit

  should('set s3 chunk_size property') do
    # Given: a value to set the chunk_size to and an S3Implementation
    chunk_size = 9000
    s3_implementation = S3Implementation.new('test')

    # When: we set the chunk size to the new value
    s3_implementation.chunk_size = chunk_size

    # We should see that the S3 base object has the new chunk size
    assert_equal chunk_size, s3_implementation.send(:s3).chunk_size
  end