dynamo-record 1.4.1 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6857b86e979ddf3e3d53a3139fa678eadef1d0bf5ab241075ac20f5d4206b194
-  data.tar.gz: f9e86c87793994a47fb1000710b857d51927e772de7104d2042dcf7043d59a38
+  metadata.gz: 193614a73977889190f759bb367f89d72ea36965a093488dc2203be83f28e37e
+  data.tar.gz: cc792d8f2d367b0fd14b7af1578d6f0a3f249b589fd8e7e880d9f40e9715b383
 SHA512:
-  metadata.gz: 4e81ce3a97bfee043a9bff671d195eb5095a12020b1f32407dd6f3f1fcd2dcfde0d83ff458b5395925d30406e39bac1b4dbce653e1ae216e357f8934b04884d3
-  data.tar.gz: fc921695c59df2a111685f7be35cc412af95c4c9429ef149b12b0518f4db2d65593415ac8835f7998f06064fe3b4294b16d0abadd8d204738b3f11278671fa69
+  metadata.gz: 9d2e98eeafd27be2c4e00e861515cd03c222de15a8eff4196377113d7791fa311b873b389037c8834cd039ab3df3590ff1e6bbdcf9c99ba09f8f567c8040acc4
+  data.tar.gz: 8250e400b5c6a63dd0d33daedf9f5d1bba2ba8f5fdba1326543075dbc2c90a91bf4c7530a1edea2b4112ee2c8f56bba8c33e115efdc6d94177c11833a784245b

data/lib/dynamo/record/version.rb

@@ -2,6 +2,6 @@
 
 module Dynamo
   module Record
-    VERSION = '1.4.1'
+    VERSION = '1.4.2'
   end
 end

data/{Gemfile → spec/gemfiles/rails-5.2.gemfile}

@@ -2,4 +2,6 @@
 
 source 'https://rubygems.org'
 
-gemspec
+gemspec path: '../../'
+
+gem 'rails', '~> 5.2.0'

data/spec/gemfiles/rails-6.0.gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'rails', '~> 6.0.0'

data/spec/gemfiles/rails-6.1.gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'rails', '~> 6.1.0'

data/spec/internal/app/models/model1.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Model1
+  include Dynamo::Record::Model
+  composite_string_attr(
+    :model1_key,
+    hash_key: true
+  )
+end

data/spec/internal/app/models/model2.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Model2
+  include Dynamo::Record::Model
+  composite_string_attr(
+    :model2_key,
+    hash_key: true
+  )
+end

data/spec/internal/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter:  sqlite3
+  database: db/combustion_test.sqlite

data/spec/internal/db/dynamo_migrate/20170402163638_create_model_1.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DynamoMigrate
+  class CreateModel1 < Dynamo::Record::TableMigration
+    def self.table_config
+      Aws::Record::TableConfig.define do |config|
+        config.model_class Model1
+        config.read_capacity_units 1
+        config.write_capacity_units 1
+      end
+    end
+  end
+end

data/spec/internal/db/dynamo_migrate/20170402163639_create_model_2.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DynamoMigrate
+  class CreateModel2 < Dynamo::Record::TableMigration
+    def self.up
+      migrate(Model2, &:create!)
+    end
+  end
+end

data/spec/internal/db/invalid_dynamo_migrate/add_model_1_stream.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DynamoMigrate
+  class AddModel1Stream < Dynamo::Record::TableMigration
+    def self.update
+      add_stream(Model1)
+    end
+  end
+end

data/spec/lib/dynamo/record/batch_get_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::BatchGet do
+  include_context 'with dummy model'
+
+  table_name = DynamoDummyModel.table_name
+
+  let(:records) { (1..5).map { |id| DynamoDummyModel.new(id: id, name: (64 + id).chr) } }
+  let(:keys) { (1..5).map { |id| { id: id } } }
+
+  before(:each) do
+    DynamoDummyModel.batch_save!(records)
+    expect(DynamoDummyModel.scan.count).to eq 5
+  end
+
+  # Overrides sleep everywhere to speed up specs.
+  before { allow_any_instance_of(Object).to receive(:sleep) }
+
+  it 'gets all at once' do
+    result = DynamoDummyModel.batch_get(keys)
+    expect(result.map(&:name).sort).to eq %w[A B C D E]
+  end
+
+  it 'handles empty array' do
+    result = DynamoDummyModel.batch_get([])
+    expect(result.count).to eq 0
+  end
+
+  it 'gets all items if item queue is larger than possible in one batch get' do
+    stub_const('Dynamo::Record::BatchGet::BATCH_SIZE', 3)
+    result = DynamoDummyModel.batch_get(keys)
+    expect(result.map(&:name).sort).to eq %w[A B C D E]
+  end
+
+  it 'raises when attempts are unsuccessful' do
+    allow(DynamoDummyModel).to receive(:max_retries).and_return(1)
+    dynamodb_client_stub = double
+    allow(DynamoDummyModel).to receive(:dynamodb_client).and_return(dynamodb_client_stub)
+    expect(dynamodb_client_stub).to receive(:batch_get_item) do |opts|
+      items = opts[:request_items][table_name][:keys]
+      Aws::DynamoDB::Types::BatchGetItemOutput.new(
+        responses: { table_name => [] },
+        unprocessed_keys: { table_name => Aws::DynamoDB::Types::KeysAndAttributes.new(keys: items) }
+      )
+    end
+    expect do
+      DynamoDummyModel.batch_get(keys)
+    end.to raise_error(Dynamo::Record::BatchGet::NumberOfRetriesExceeded)
+  end
+
+  it 'reprocesses unprocessed items' do
+    dynamodb_client_stub = double
+    original_batch_get_item = DynamoDummyModel.dynamodb_client.method(:batch_get_item)
+    allow(DynamoDummyModel).to receive(:dynamodb_client).and_return(dynamodb_client_stub)
+    expect(dynamodb_client_stub).to receive(:batch_get_item) do |opts|
+      # Pick two successful items, return the remaining keys
+      items = opts[:request_items][table_name][:keys]
+      success = items.sample(2)
+      response = original_batch_get_item.call(opts)
+      pr, = response.responses[table_name].partition { |r| success.map { |i| i['id'] }.include? r['id'] }
+      unpr = items - success
+      Aws::DynamoDB::Types::BatchGetItemOutput.new(
+        responses: { table_name => pr },
+        unprocessed_keys: { table_name => Aws::DynamoDB::Types::KeysAndAttributes.new(keys: unpr) }
+      )
+    end.exactly(3).times
+    result = DynamoDummyModel.batch_get(keys)
+    expect(result.map(&:name).sort).to eq %w[A B C D E]
+  end
+
+  it 'retries if provisioned throughput is exceeded' do
+    stub_const('Dynamo::Record::BatchGet::BATCH_SIZE', 3)
+    call_count = 0
+    original_batch_get_item = DynamoDummyModel.dynamodb_client.method(:batch_get_item)
+    expect(DynamoDummyModel.dynamodb_client).to receive(:batch_get_item) do |opts|
+      call_count += 1
+      raise Aws::DynamoDB::Errors::ProvisionedThroughputExceededException.new(nil, nil) if call_count == 1
+
+      original_batch_get_item.call(opts)
+    end.exactly(3).times
+
+    result = DynamoDummyModel.batch_get(keys)
+    expect(result.map(&:name).sort).to eq %w[A B C D E]
+  end
+end

data/spec/lib/dynamo/record/batch_write_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::BatchWrite do
+  include_context 'with dummy model'
+
+  shared_examples_for 'a batch write' do |method|
+    # Overrides sleep everywhere to speed up specs.
+    before { allow_any_instance_of(Object).to receive(:sleep) }
+
+    it 'writes all at once' do
+      DynamoDummyModel.send(method, records)
+      expect(DynamoDummyModel.scan.count).to eq expected_count
+    end
+
+    it 'handles empty array' do
+      DynamoDummyModel.send(method, [])
+      expect(DynamoDummyModel.scan.count).to eq num_records
+    end
+
+    it 'writes all items if item queue is larger than possible in one batch write' do
+      stub_const('Dynamo::Record::BatchWrite::BATCH_SIZE', 3)
+      DynamoDummyModel.send(method, records)
+      expect(DynamoDummyModel.scan.count).to eq expected_count
+    end
+
+    it 'writes all items if payload size would be exceeded in a single write' do
+      stub_const('Dynamo::Record::BatchWrite::MAX_PAYLOAD_SIZE', 50)
+      records = (1..5).map { |id| DynamoDummyModel.new(id: id) }
+      DynamoDummyModel.send(method, records)
+      expect(DynamoDummyModel.scan.count).to eq expected_count
+    end
+
+    it 'reprocesses unprocessed items' do
+      records = [DynamoDummyModel.new(id: 1)]
+      dynamodb_client_stub = double
+      expect(DynamoDummyModel).to receive(:max_retries).and_return(1).exactly(2).times
+      expect(DynamoDummyModel).to receive(:dynamodb_client).and_return(dynamodb_client_stub).exactly(2).times
+      allow(dynamodb_client_stub).to receive(:batch_write_item) do |opts|
+        items = opts[:request_items][DynamoDummyModel.table_name].map { |ri| Aws::DynamoDB::Types::WriteRequest.new ri }
+        double(unprocessed_items: { DynamoDummyModel.table_name => items })
+      end
+      expect do
+        DynamoDummyModel.send(method, records)
+      end.to raise_error(Dynamo::Record::BatchWrite::NumberOfRetriesExceeded)
+    end
+
+    it 'fails if a record is too large' do
+      stub_const('Dynamo::Record::BatchRequest::MAX_RECORD_SIZE', 5)
+      expect do
+        DynamoDummyModel.send(method, records)
+      end.to raise_error(Dynamo::Record::RecordTooLargeError)
+    end
+
+    it 'retries if provisioned throughput is exceeded' do
+      stub_const('Dynamo::Record::BatchWrite::BATCH_SIZE', 3)
+      call_count = 0
+      original_batch_write_item = DynamoDummyModel.dynamodb_client.method(:batch_write_item)
+      expect(DynamoDummyModel.dynamodb_client).to receive(:batch_write_item) do |opts|
+        call_count += 1
+        raise Aws::DynamoDB::Errors::ProvisionedThroughputExceededException.new(nil, nil) if call_count == 1
+
+        original_batch_write_item.call(opts)
+      end.exactly(3).times
+
+      DynamoDummyModel.send(method, records)
+      expect(DynamoDummyModel.scan.count).to eq expected_count
+    end
+  end
+
+  describe '.batch_save!' do
+    let(:records) { (1..5).map { |id| DynamoDummyModel.new(id: id) } }
+    let(:expected_count) { 5 }
+    let(:num_records) { 0 }
+
+    it_behaves_like 'a batch write', :batch_save!
+  end
+
+  describe '.batch_delete!' do
+    let(:records) { (1..5).map { |id| DynamoDummyModel.new(id: id) } }
+    let(:expected_count) { 0 }
+    let(:num_records) { 5 }
+
+    before(:each) do
+      DynamoDummyModel.batch_save!(records)
+      expect(DynamoDummyModel.scan.count).to eq 5
+    end
+
+    it_behaves_like 'a batch write', :batch_delete!
+  end
+end

data/spec/lib/dynamo/record/model_existence_vaildator_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::ModelExistenceValidator do
+  class TestModel
+    def self.exists?(id)
+      id == 1
+    end
+  end
+
+  describe '#validate_each' do
+    before(:each) do
+      validator.validate_each(record, :test_model_id, value)
+    end
+
+    let(:record) do
+      Class.new do
+        attr_accessor :errors
+
+        def initialize
+          @errors = { test_model_id: [] }
+        end
+      end.new
+    end
+
+    let(:validator) { described_class.new(attributes: [:test_model_id], model: TestModel) }
+
+    context 'valid record' do
+      let(:value) { 1 }
+
+      it 'has no errors' do
+        expect(record.errors[:test_model_id]).to be_empty
+      end
+    end
+
+    context 'invalid record' do
+      let(:value) { 2 }
+
+      it 'has errors' do
+        expect(record.errors[:test_model_id]).not_to be_empty
+      end
+    end
+  end
+end

data/spec/lib/dynamo/record/model_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::Model do
+  class TestDynamoModel
+    include Dynamo::Record::Model
+
+    integer_attr :test_id_1, hash_key: true
+    integer_attr :test_id_2, range_key: true
+    integer_attr :test_id_3
+    composite_integer_attr(
+      :test_id_4,
+      parts: %i[test_id_4_1 test_id_4_2]
+    )
+
+    global_secondary_index(
+      :gsi_1,
+      hash_key: :test_id_3,
+      range_key: :test_id_2,
+      projection: {
+        projection_type: 'ALL'
+      }
+    )
+
+    local_secondary_index(
+      :lsi_1,
+      range_key: :test_id_3,
+      projection: {
+        projection_type: 'ALL'
+      }
+    )
+  end
+
+  describe '.table_name' do
+    it 'should have correct table name' do
+      expect(TestDynamoModel.table_name).to eq 'test-test_dynamo_models'
+    end
+  end
+
+  context 'composite keys' do
+    before do
+      @d_1 = 'data_1'
+      @d_2 = 'data_2'
+      @key = TestDynamoModel.composite_key(@d_1, @d_2)
+    end
+
+    describe '.split_composite' do
+      it 'returns the input from composite_key' do
+        r_1, r_2 = TestDynamoModel.split_composite(@key)
+        expect(r_1).to eq @d_1
+        expect(r_2).to eq @d_2
+      end
+    end
+
+    describe '.composite_key' do
+      it 'returns the composite key' do
+        expect(@key).to eq "#{@d_1}|#{@d_2}"
+      end
+    end
+  end
+
+  describe '.find' do
+    it 'raises Aws::Record::Errors::NotFound if no record matches' do
+      resp = Aws::DynamoDB::Types::GetItemOutput.new
+      expect(TestDynamoModel.dynamodb_client).to receive(:get_item).once.and_return(resp)
+      expect { TestDynamoModel.find(test_id_1: 'omg', test_id_2: 'pls') }.to raise_error(Aws::Record::Errors::NotFound)
+    end
+  end
+
+  context 'find queries' do
+    before do
+      expect(TestDynamoModel).to receive(:query).once
+    end
+
+    describe '.find_all_by_hash_key' do
+      it 'queries by hash key' do
+        TestDynamoModel.find_all_by_hash_key(1)
+      end
+    end
+
+    describe '.find_all_by_gsi_hash_key' do
+      it 'queries the gsi' do
+        TestDynamoModel.find_all_by_gsi_hash_key('gsi_1', 1)
+      end
+    end
+
+    describe '.find_all_by_gsi_hash_and_range_keys' do
+      it 'queries the gsi' do
+        TestDynamoModel.find_all_by_gsi_hash_and_range_keys('gsi_1', 1, 5)
+      end
+    end
+
+    describe '.find_all_by_lsi_hash_key' do
+      it 'queries the lsi' do
+        TestDynamoModel.find_all_by_lsi_hash_key('lsi_1', 1)
+      end
+    end
+
+    describe '.find_all_by_lsi_hash_and_range_keys' do
+      it 'queries the lsi' do
+        TestDynamoModel.find_all_by_lsi_hash_and_range_keys('lsi_1', 1, 3)
+      end
+    end
+
+    describe '.find_all_by_index_hash_and_range_keys' do
+      it 'can fetch item ranges' do
+        hash = { name: 'test_id_1', value: 2 }
+        range = { expression: 'test_id_2 > :rkv', value: 10 }
+        TestDynamoModel.find_all_by_index_hash_and_range_keys(hash_config: hash, range_config: range)
+      end
+    end
+  end
+
+  describe '#read_attribute_for_serialization' do
+    it 'generates an attribute hash' do
+      key = TestDynamoModel.composite_key(4, 5)
+      m = TestDynamoModel.new(test_id_1: 1, test_id_2: 2, test_id_3: 3, test_id_4: key)
+      expect(m.attribute_hash).to eq(test_id_1: 1, test_id_2: 2, test_id_3: 3, test_id_4: key)
+    end
+  end
+end

data/spec/lib/dynamo/record/table_migration_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::TableMigration do
+  class TestDynamoTableMigration
+    include Aws::Record
+
+    integer_attr :test_id_1, hash_key: true
+    integer_attr :test_id_2, range_key: true
+  end
+
+  class CreateTestDynamoTableMigration < Dynamo::Record::TableMigration
+    def self.up
+      migrate(TestDynamoTableMigration) do |migration|
+        migration.create!(
+          provisioned_throughput: {
+            read_capacity_units: 1,
+            write_capacity_units: 1
+          }
+        )
+      end
+    end
+  end
+
+  let(:client) { double(describe_table: true) }
+
+  describe '.migrate' do
+    it 'returns `:migrated` if successful' do
+      expect_any_instance_of(Aws::Record::TableMigration).to receive(:client).and_return(client)
+      expect(client).to receive(:describe_table).and_raise(
+        Aws::DynamoDB::Errors::ResourceNotFoundException.new(nil, '')
+      )
+
+      expect_any_instance_of(Aws::Record::TableMigration).to receive(:create!).once
+      expect_any_instance_of(Aws::Record::TableMigration).to receive(:wait_until_available).once
+
+      expect(CreateTestDynamoTableMigration.up).to eq :migrated
+    end
+
+    it 'returns `:exists` if table already exists' do
+      expect_any_instance_of(Aws::Record::TableMigration).to receive(:client).and_return(client)
+
+      expect(CreateTestDynamoTableMigration.up).to eq :exists
+    end
+  end
+
+  describe '.add_stream' do
+    it 'raises an error if ValidationException raised' do
+      allow_any_instance_of(Aws::Record::TableMigration).to(
+        receive(:update!).and_raise(Aws::DynamoDB::Errors::ValidationException.new(nil, nil))
+      )
+      expect { CreateTestDynamoTableMigration.add_stream(TestDynamoTableMigration) }.to(
+        raise_error Aws::DynamoDB::Errors::ValidationException
+      )
+    end
+
+    it 'does not raise an excetion if stream already enabled' do
+      message = 'Table already has an enabled stream'
+      expect_any_instance_of(Aws::DynamoDB::Errors::ValidationException).to(
+        receive(:message).at_least(:once).and_return(message)
+      )
+      allow_any_instance_of(Aws::Record::TableMigration).to(
+        receive(:update!).and_raise(Aws::DynamoDB::Errors::ValidationException.new(nil, ''))
+      )
+      expect { CreateTestDynamoTableMigration.add_stream(TestDynamoTableMigration) }.to_not raise_error
+      expect(CreateTestDynamoTableMigration.add_stream(TestDynamoTableMigration)).to eq message
+    end
+  end
+end

data/spec/lib/dynamo/record/task_helpers/cleanup_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::TaskHelpers::Cleanup do
+  describe '.run' do
+    it 'raises error if rails is in production' do
+      allow(Rails).to receive(:env).and_return(
+        ActiveSupport::StringInquirer.new('production')
+      )
+      expect do
+        Dynamo::Record::TaskHelpers::Cleanup.run
+      end.to raise_error('Task not available on production')
+    end
+
+    it 'deletes records in all DynamoDB tables' do
+      Dir[Rails.root.join('app/models/*.rb').to_s].each do |filename|
+        klass = File.basename(filename, '.rb').camelize.constantize
+        next unless klass.included_modules.include? Dynamo::Record::Model
+
+        object = double.as_null_object
+        list = [object]
+        expect(klass).to receive(:scan).and_return(list)
+        expect(object).to receive(:delete!)
+      end
+
+      described_class.run
+    end
+  end
+end

data/spec/lib/dynamo/record/task_helpers/drop_all_tables_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::TaskHelpers::DropAllTables do
+  describe '.run' do
+    it 'raises error if rails is in production' do
+      allow(Rails).to receive(:env).and_return(
+        ActiveSupport::StringInquirer.new('production')
+      )
+      expect do
+        Dynamo::Record::TaskHelpers::DropAllTables.run
+      end.to raise_error('Task not available on production')
+    end
+
+    it 'drops all dynamo tables' do
+      expect_any_instance_of(Aws::DynamoDB::Client).to receive(:list_tables)
+        .and_return double(table_names: %w[test_t1 test_t2 test_t3])
+      expect_any_instance_of(Aws::DynamoDB::Client).to receive(:delete_table).at_least(3).times
+      Dynamo::Record::TaskHelpers::DropAllTables.run
+    end
+  end
+end

data/spec/lib/dynamo/record/task_helpers/drop_table_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::TaskHelpers::DropTable do
+  include_context 'with dummy model'
+
+  class BadDummyModel; end # rubocop:disable Lint/EmptyClass
+
+  describe '#run' do
+    it 'raises error if specified class does not include Aws::Record' do
+      expect do
+        Dynamo::Record::TaskHelpers::DropTable.run('BadDummyModel')
+      end.to raise_error('Cannot do operations on a non-existent table')
+    end
+
+    it 'drops dynamo table' do
+      dynamodb = Aws::DynamoDB::Client.new
+      table = dynamodb.describe_table(table_name: DynamoDummyModel.table_name)
+      expect(table).not_to be_empty
+
+      Dynamo::Record::TaskHelpers::DropTable.run DynamoDummyModel.table_name
+
+      expect do
+        dynamodb.describe_table(table_name: DynamoDummyModel.table_name)
+      end.to raise_error(Aws::DynamoDB::Errors::ResourceNotFoundException)
+    end
+  end
+end

data/spec/lib/dynamo/record/task_helpers/list_tables_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::TaskHelpers::ListTables do
+  describe '#run' do
+    include_context 'with dummy model'
+    it 'lists all dynamo tables' do
+      list = Dynamo::Record::TaskHelpers::ListTables.run
+
+      expect(list).to include DynamoDummyModel.table_name
+    end
+  end
+end

data/spec/lib/dynamo/record/task_helpers/migration_runner_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::TaskHelpers::MigrationRunner do
+  describe '.run' do
+    it 'runs migration for each dynamo table' do
+      allow_any_instance_of(Aws::Record::TableMigration).to(
+        receive(:client).and_raise(
+          Aws::DynamoDB::Errors::ResourceNotFoundException.new(nil, '')
+        )
+      )
+
+      allow_any_instance_of(Aws::Record::TableMigration).to receive(:create!)
+      allow_any_instance_of(Aws::Record::TableConfig).to receive(:migrate!)
+      allow_any_instance_of(Aws::Record::TableMigration).to receive(:update!)
+      allow_any_instance_of(Aws::Record::TableMigration).to receive(:wait_until_available)
+      messages = []
+
+      Dynamo::Record::TaskHelpers::MigrationRunner.run do |thing|
+        messages << thing
+      end
+
+      switch = true
+      messages.each do |message|
+        expect(message).to include(switch ? 'Migrating:' : 'Migration successful')
+        switch = !switch
+      end
+    end
+
+    it 'displays failed migrations' do
+      allow_any_instance_of(Aws::Record::TableConfig).to(
+        receive(:migrate!).and_raise(
+          StandardError.new('')
+        )
+      )
+      messages = []
+
+      Dynamo::Record::TaskHelpers::MigrationRunner.run do |thing|
+        messages << thing
+      end
+
+      switch = true
+      messages.each do |message|
+        expect(message).to include(switch ? 'Migrating:' : 'Migration failed')
+        switch = !switch
+      end
+    end
+
+    it 'raises on non-numeric prefixes' do
+      expect do
+        Dynamo::Record::TaskHelpers::MigrationRunner.run('db/invalid_dynamo_migrate')
+      end.to raise_error(/Non-numeric prefix/)
+    end
+  end
+end

data/spec/lib/dynamo/record/task_helpers/scale_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record::TaskHelpers::Scale do
+  include_context 'with dummy model'
+
+  describe '.run' do
+    it 'changes both throughputs on the table' do
+      migration = Aws::Record::TableMigration.new(DynamoDummyModel)
+      current_settings = migration.client.describe_table(table_name: DynamoDummyModel.table_name).table
+
+      # configure unique throughput settings so ordering doesn't matter
+      new_throughput = current_settings.provisioned_throughput.read_capacity_units == 50 ? 49 : 50
+
+      # Run the scaling
+      scale = Dynamo::Record::TaskHelpers::Scale.new 'DynamoDummyModel', 'both', new_throughput
+      scale.run
+      throughput = migration.client.describe_table(table_name: DynamoDummyModel.table_name).table.provisioned_throughput
+      expect(throughput.read_capacity_units).to eq(new_throughput)
+      expect(throughput.write_capacity_units).to eq(new_throughput)
+    end
+
+    it 'changes the write throughput on the table' do
+      migration = Aws::Record::TableMigration.new(DynamoDummyModel)
+      current_settings = migration.client.describe_table(table_name: DynamoDummyModel.table_name).table
+
+      # configure unique throughput settings so ordering doesn't matter
+      new_write_throughput = current_settings.provisioned_throughput.write_capacity_units == 20 ? 19 : 20
+
+      # Run the scaling
+      scale = Dynamo::Record::TaskHelpers::Scale.new 'DynamoDummyModel', 'write', new_write_throughput
+      scale.run
+
+      throughput = migration.client.describe_table(table_name: DynamoDummyModel.table_name).table.provisioned_throughput
+      expect(throughput.write_capacity_units).to eq(new_write_throughput)
+    end
+
+    it 'changes the read throughput on the table' do
+      migration = Aws::Record::TableMigration.new(DynamoDummyModel)
+      current_settings = migration.client.describe_table(table_name: DynamoDummyModel.table_name).table
+
+      # configure unique throughput settings so ordering doesn't matter
+      new_read_throughput = current_settings.provisioned_throughput.read_capacity_units == 20 ? 19 : 20
+
+      # Run the scaling
+      scale = Dynamo::Record::TaskHelpers::Scale.new 'DynamoDummyModel', 'read', new_read_throughput
+      scale.run
+
+      throughput = migration.client.describe_table(table_name: DynamoDummyModel.table_name).table.provisioned_throughput
+      expect(throughput.read_capacity_units).to eq(new_read_throughput)
+    end
+
+    it 'prints description if any param is blank' do
+      message = Dynamo::Record::TaskHelpers::Scale.new('DynamoDummyModel', 'read', nil).run
+      expect(message).to include('Here\'s some usage information:')
+    end
+
+    it 'raises exception if attribute selection is invalid' do
+      scale = Dynamo::Record::TaskHelpers::Scale.new('DynamoDummyModel', 'invalid_selection', 20)
+      expect { scale.run }.to raise_error(
+        /provide an appropriate attribute selection/
+      )
+    end
+  end
+end

data/spec/lib/dynamo/record/version_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+describe Dynamo::Record do
+  it 'has a version number' do
+    expect(Dynamo::Record::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Limit coverage reporting to one build:
+if /^2\.6/ =~ RUBY_VERSION && /6\.0/ =~ ENV['BUNDLE_GEMFILE']
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter 'lib/dynamo/record/version.rb'
+    add_filter 'spec'
+    track_files 'lib/**/*.rb'
+  end
+
+  SimpleCov.minimum_coverage(94)
+end
+
+require 'bundler'
+Bundler.require :default, :development
+
+Combustion.initialize! do
+  config.dynamo = { 'prefix' => 'test' }
+end
+
+Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+Aws.config.update(
+  dynamodb: { endpoint: ENV['DYNAMO_ENDPOINT'] }
+)
+
+WebMock.disable_net_connect!(allow: ['dynamo:8000'])

data/spec/support/shared_contexts/with_dummy_model.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+RSpec.shared_context 'with dummy model' do
+  class DynamoDummyModel
+    include Aws::Record
+    include Dynamo::Record::Model
+
+    integer_attr :id, hash_key: true
+    string_attr :name
+  end
+
+  before do
+    migration = Aws::Record::TableMigration.new(DynamoDummyModel)
+    migration.create!(
+      provisioned_throughput: {
+        read_capacity_units: 1,
+        write_capacity_units: 1
+      }
+    )
+  end
+
+  after do
+    dynamodb = Aws::DynamoDB::Client.new
+    dynamodb.delete_table table_name: DynamoDummyModel.table_name
+  rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+    # some tests will drop this table
+  end
+end

metadata

@@ -1,20 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamo-record
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.4.2
 platform: ruby
 authors:
-- Davis McClellan
-- Ryan Taylor
-- Bryan Petty
-- Michael Brewer-Davis
-- Marc Phillips
-- Augusto Callejas
-- Frank Murphy
+- Alex Slaughter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-03 00:00:00.000000000 Z
+date: 2023-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -232,30 +226,12 @@ dependencies:
         version: '1.3'
 description: 
 email:
-- dmcclellan@instructure.com
-- rtaylor@instructure.com
-- bpetty@instructure.com
-- mbd@instructure.com
-- mphillips@instructure.com
-- acallejas@instructure.com
-- fmurphy@instructure.com
+- aslaughter@instructure.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".dockerignore"
-- ".gitignore"
-- ".rspec"
-- ".rubocop.yml"
-- ".travis.yml"
-- Dockerfile
-- Gemfile
-- Jenkinsfile
-- LICENSE.txt
 - README.md
-- docker-compose.override.example.yml
-- docker-compose.yml
-- dynamo-record.gemspec
 - lib/dynamo/record.rb
 - lib/dynamo/record/batch_get.rb
 - lib/dynamo/record/batch_request.rb
@@ -273,6 +249,29 @@ files:
 - lib/dynamo/record/task_helpers/scale.rb
 - lib/dynamo/record/version.rb
 - lib/tasks/dynamo.rake
+- spec/gemfiles/rails-5.2.gemfile
+- spec/gemfiles/rails-6.0.gemfile
+- spec/gemfiles/rails-6.1.gemfile
+- spec/internal/app/models/model1.rb
+- spec/internal/app/models/model2.rb
+- spec/internal/config/database.yml
+- spec/internal/db/dynamo_migrate/20170402163638_create_model_1.rb
+- spec/internal/db/dynamo_migrate/20170402163639_create_model_2.rb
+- spec/internal/db/invalid_dynamo_migrate/add_model_1_stream.rb
+- spec/lib/dynamo/record/batch_get_spec.rb
+- spec/lib/dynamo/record/batch_write_spec.rb
+- spec/lib/dynamo/record/model_existence_vaildator_spec.rb
+- spec/lib/dynamo/record/model_spec.rb
+- spec/lib/dynamo/record/table_migration_spec.rb
+- spec/lib/dynamo/record/task_helpers/cleanup_spec.rb
+- spec/lib/dynamo/record/task_helpers/drop_all_tables_spec.rb
+- spec/lib/dynamo/record/task_helpers/drop_table_spec.rb
+- spec/lib/dynamo/record/task_helpers/list_tables_spec.rb
+- spec/lib/dynamo/record/task_helpers/migration_runner_spec.rb
+- spec/lib/dynamo/record/task_helpers/scale_spec.rb
+- spec/lib/dynamo/record/version_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_contexts/with_dummy_model.rb
 homepage: https://github.com/instructure/dynamo-record
 licenses:
 - MIT
@@ -292,8 +291,31 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: Extensions to Aws::Record for working with DynamoDB.
-test_files: []
+test_files:
+- spec/gemfiles/rails-5.2.gemfile
+- spec/gemfiles/rails-6.0.gemfile
+- spec/gemfiles/rails-6.1.gemfile
+- spec/internal/app/models/model1.rb
+- spec/internal/app/models/model2.rb
+- spec/internal/config/database.yml
+- spec/internal/db/dynamo_migrate/20170402163638_create_model_1.rb
+- spec/internal/db/dynamo_migrate/20170402163639_create_model_2.rb
+- spec/internal/db/invalid_dynamo_migrate/add_model_1_stream.rb
+- spec/lib/dynamo/record/batch_get_spec.rb
+- spec/lib/dynamo/record/batch_write_spec.rb
+- spec/lib/dynamo/record/model_existence_vaildator_spec.rb
+- spec/lib/dynamo/record/model_spec.rb
+- spec/lib/dynamo/record/table_migration_spec.rb
+- spec/lib/dynamo/record/task_helpers/cleanup_spec.rb
+- spec/lib/dynamo/record/task_helpers/drop_all_tables_spec.rb
+- spec/lib/dynamo/record/task_helpers/drop_table_spec.rb
+- spec/lib/dynamo/record/task_helpers/list_tables_spec.rb
+- spec/lib/dynamo/record/task_helpers/migration_runner_spec.rb
+- spec/lib/dynamo/record/task_helpers/scale_spec.rb
+- spec/lib/dynamo/record/version_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_contexts/with_dummy_model.rb

data/.dockerignore

@@ -1,17 +0,0 @@
-/.gitignore
-/.rspec_status
-/.ruby-version
-/coverage/
-/doc/
-/Dockerfile
-/docker-compose.yml
-/docker-compose.override.example.yml
-/docker-compose.override.yml
-/dynamo-record-*.gem
-/Gemfile.lock
-/log/
-/pkg/
-/spec/gemfiles/.bundle/
-/spec/gemfiles/*.gemfile.lock
-/switchman-inst-jobs-*.gem
-/tmp/

data/.gitignore

@@ -1,16 +0,0 @@
-/.bundle/
-/.rspec_status
-/.ruby-version
-/.yardoc
-/_yardoc/
-/coverage/
-/docker-compose.override.yml
-/dynamo-record-*.gem
-/Gemfile.lock
-/pkg/
-/spec/gemfiles/.bundle/
-/spec/dummy/log/
-/spec/dummy/tmp/
-/spec/gemfiles/*.gemfile.lock
-/spec/reports/
-/tmp/

data/.rspec

@@ -1,2 +0,0 @@
---color
---require spec_helper

data/.rubocop.yml

@@ -1,61 +0,0 @@
-require:
-  - rubocop-rails
-
-AllCops:
-  NewCops: enable
-  SuggestExtensions: false
-  TargetRailsVersion: 5.2
-  TargetRubyVersion: 2.6
-
-Metrics/AbcSize:
-  Max: 20 # Default: 15
-
-Metrics/ClassLength:
-  Max: 200 # Default: 100
-
-Metrics/MethodLength:
-  Max: 20 # Default: 10
-
-Metrics/BlockLength:
-  Max: 30
-  Exclude:
-    - dynamo-record.gemspec
-    - spec/**/*.rb
-
-Layout/EndAlignment:
-  EnforcedStyleAlignWith: variable
-
-Layout/LineLength:
-  Max: 120 # Default: 80
-
-Layout/ParameterAlignment:
-  # Alignment of parameters in multi-line method calls.
-  #
-  # The `with_fixed_indentation` style aligns the following lines with one
-  # level of indentation relative to the start of the line with the method call.
-  #
-  #     method_call(a,
-  #       b)
-  EnforcedStyle: with_fixed_indentation
-
-Lint/ConstantDefinitionInBlock:
-  Exclude:
-    - spec/**/*.rb
-
-Naming/FileName:
-  Exclude:
-    - spec/gemfiles/*
-
-Naming/VariableNumber:
-  EnforcedStyle: snake_case
-
-Style/Documentation:
-  # This cop checks for missing top-level documentation of classes and modules.
-  # Classes with no body and namespace modules are exempt from the check.
-  # Namespace modules are modules that have nothing in their bodies except
-  # classes or other modules.
-  Enabled: false
-
-Style/NumericPredicate:
-  Exclude:
-    - spec/**/*.rb

data/.travis.yml

@@ -1,28 +0,0 @@
-dist: trusty
-sudo: false
-language: ruby
-cache: bundler
-
-rvm:
-  - 2.6
-  - 2.7
-  - 3.0
-
-gemfile:
-  - spec/gemfiles/rails-5.2.gemfile
-  - spec/gemfiles/rails-6.0.gemfile
-  - spec/gemfiles/rails-6.1.gemfile
-
-# Rails 5.2 doesn't support Ruby 3.0, so don't try
-matrix:
-  exclude:
-  - rvm: 3.0
-    gemfile: spec/gemfiles/rails-5.2.gemfile
-
-before_install: gem update bundler
-bundler_args: --jobs 3
-install: bundle install --jobs 3
-
-script:
-  - bash -c "if [ '$TRAVIS_RUBY_VERSION' = '3.0' ] && [[ '$BUNDLE_GEMFILE' == *'rails-6.1'* ]]; then bundle exec rubocop --fail-level autocorrect; fi"
-  - bundle exec rspec

data/Dockerfile

@@ -1,24 +0,0 @@
-FROM instructure/rvm
-
-WORKDIR /app
-USER root
-RUN chown -R docker:docker /app
-RUN apt-get update
-RUN apt-get install -y git
-
-USER docker
-
-COPY --chown=docker:docker dynamo-record.gemspec Gemfile /app/
-COPY --chown=docker:docker lib/dynamo/record/version.rb /app/lib/dynamo/record/version.rb
-
-RUN mkdir -p coverage \
-             spec/gemfiles/.bundle \
-             spec/internal/log
-
-RUN bash -lc "rvm 2.6,2.7,3.0 do gem install --no-document bundler -v '~> 2.2'"
-RUN bash -lc "cd /app && rvm-exec 2.6 bundle install --jobs 5"
-RUN bash -lc "cd /app && rvm-exec 2.7 bundle install --jobs 5"
-RUN bash -lc "cd /app && rvm-exec 3.0 bundle install --jobs 5"
-COPY --chown=docker:docker . /app
-
-CMD /bin/bash -lc "rvm-exec 3.0 bundle exec wwtd"

data/Jenkinsfile

@@ -1,45 +0,0 @@
-#!/usr/bin/env groovy
-
-pipeline {
-    agent {
-        label 'docker'
-    }
-    options {
-        ansiColor("xterm")
-        buildDiscarder(logRotator(numToKeepStr: '50'))
-        timeout(time: 20, unit: 'MINUTES')
-    }
-    stages {
-        stage('Build') {
-            steps {
-                sh 'docker-compose pull dynamo'
-                sh 'docker-compose up -d dynamo'
-                sh 'docker-compose build --pull app'
-            }
-        }
-        stage('Test') {
-            steps {
-                sh '''
-                    docker-compose run --rm app /bin/bash -l -c \
-                        "rvm-exec 3.0 bundle exec rubocop --fail-level autocorrect"
-                    docker-compose run --name coverage app
-                '''
-            }
-            post {
-                always {
-                    sh 'docker cp coverage:/app/coverage .'
-                    sh 'docker-compose down --rmi=all --volumes --remove-orphans'
-
-                    publishHTML target: [
-                      allowMissing: false,
-                      alwaysLinkToLastBuild: false,
-                      keepAll: true,
-                      reportDir: "coverage",
-                      reportFiles: 'index.html',
-                      reportName: 'Coverage Report'
-                    ]
-                }
-            }
-        }
-    }
-}

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2017 Instructure, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/docker-compose.override.example.yml

@@ -1,19 +0,0 @@
-version: '2'
-
-services:
-  app:
-    volumes:
-      - .:/app
-      - gems:/home/docker/.rvm/gems
-      # Disable the rest of these volumes if the container can safely write to
-      # your host filesystem mount named above. You might want to use the rest
-      # of these unless you're using dinghy on OSX (usually needed for linux).
-      - coverage:/app/coverage
-      - bundle-config:/app/spec/gemfiles/.bundle
-      - internal-log:/app/spec/internal/log
-
-volumes:
-  coverage: {}
-  bundle-config: {}
-  gems: {}
-  internal-log: {}

data/docker-compose.yml

@@ -1,20 +0,0 @@
-version: '2'
-
-services:
-  app:
-    build: .
-    environment:
-      AWS_ACCESS_KEY_ID: x
-      AWS_SECRET_ACCESS_KEY: x
-      AWS_REGION: us-west-2
-      DYNAMO_ENDPOINT: http://dynamo:8000
-      RAILS_ENV: test
-    logging:
-      options:
-        max-file: '1'
-        max-size: 5m
-    links:
-      - dynamo
-
-  dynamo:
-    image: instructure/dynamodb

data/dynamo-record.gemspec

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'dynamo/record/version'
-
-Gem::Specification.new do |s|
-  s.name          = 'dynamo-record'
-  s.version       = Dynamo::Record::VERSION
-  s.summary       = 'Extensions to Aws::Record for working with DynamoDB.'
-  s.homepage      = 'https://github.com/instructure/dynamo-record'
-  s.license       = 'MIT'
-
-  s.authors       = [
-    'Davis McClellan',
-    'Ryan Taylor',
-    'Bryan Petty',
-    'Michael Brewer-Davis',
-    'Marc Phillips',
-    'Augusto Callejas',
-    'Frank Murphy'
-  ]
-  s.email = [
-    'dmcclellan@instructure.com',
-    'rtaylor@instructure.com',
-    'bpetty@instructure.com',
-    'mbd@instructure.com',
-    'mphillips@instructure.com',
-    'acallejas@instructure.com',
-    'fmurphy@instructure.com'
-  ]
-
-  s.files = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  s.require_paths = ['lib']
-
-  s.required_ruby_version = '>= 2.6'
-
-  s.add_dependency 'activemodel', '>= 5.2', '< 6.2'
-  s.add_dependency 'aws-record', '~> 2.0'
-  s.add_dependency 'railties', '>= 5.2', '< 6.2'
-
-  s.add_development_dependency 'activesupport', '>= 5.2', '< 6.2'
-  s.add_development_dependency 'bundler', '~> 2.2'
-  s.add_development_dependency 'byebug', '~> 11.0'
-  s.add_development_dependency 'combustion', '~> 1.3'
-  s.add_development_dependency 'rake', '~> 13.0'
-  s.add_development_dependency 'rspec', '~> 3.6'
-  s.add_development_dependency 'rubocop', '~> 1.8.1'
-  s.add_development_dependency 'rubocop-rails', '~> 2.9.1'
-  s.add_development_dependency 'simplecov', '~> 0.16'
-  s.add_development_dependency 'webmock', '~> 3.3'
-  s.add_development_dependency 'wwtd', '~> 1.3'
-end