simmer 1.0.0.pre.alpha.3 → 1.0.0.pre.alpha.4

data/spec/simmer/specification/act/params_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe Simmer::Specification::Act::Params do
+  let(:spec_path)     { File.join('specifications', 'load_noc_list.yaml') }
+  let(:params_config) { yaml_fixture(spec_path).dig('act', 'params') }
+
+  let(:config) do
+    {
+      codes: {
+        the_secret_one: '123ABC'
+      }
+    }
+  end
+
+  let(:files_path) { 'files_are_here' }
+
+  subject { described_class.make(params_config) }
+
+  it '#compile combines files and keys' do
+    actual        = subject.compile(files_path, config)
+    expected_path = File.expand_path(File.join(files_path, subject.files.values.first))
+    expected      = {
+      'input_file' => expected_path,
+      'code' => 'The secret code is: 123ABC'
+    }
+
+    expect(actual).to eq(expected)
+  end
+end

data/spec/simmer/specification/act_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe Simmer::Specification::Act do
+  let(:path) { File.join('specifications', 'load_noc_list.yaml') }
+
+  let(:config) { yaml_fixture(path)['act'] }
+
+  describe 'initialization using acts_as_hashable' do
+    subject { described_class.make(config) }
+
+    it 'sets repository' do
+      expect(subject.repository).to eq('top_secret')
+    end
+
+    it 'sets name' do
+      expect(subject.name).to eq('load_noc_list')
+    end
+
+    it 'sets type' do
+      expect(subject.type).to eq('transformation')
+    end
+
+    it 'sets params' do
+      expect(subject.params.files).to eq('input_file' => 'noc_list.csv')
+      expect(subject.params.keys).to  eq('code' => 'The secret code is: {codes.the_secret_one}')
+    end
+  end
+end

data/spec/simmer/specification/assert_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe Simmer::Specification::Assert do
+  let(:path) { File.join('specifications', 'load_noc_list.yaml') }
+
+  let(:config) { yaml_fixture(path)['assert'] }
+
+  describe 'initialization using acts_as_hashable' do
+    subject { described_class.make(config) }
+
+    it 'sets assertions' do
+      expect(subject.assertions.length).to                  eq(2)
+      expect(subject.assertions.first.name).to              eq('agents')
+      expect(subject.assertions.first.record_set.length).to eq(2)
+      expect(subject.assertions.last.value).to              eq('Decoding Agents')
+    end
+  end
+end

data/spec/simmer/specification/stage_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe Simmer::Specification::Stage do
+  let(:path) { File.join('specifications', 'load_noc_list.yaml') }
+
+  let(:config) { yaml_fixture(path)['stage'] }
+
+  describe 'initialization using acts_as_hashable' do
+    subject { described_class.make(config) }
+
+    it 'sets files' do
+      expect(subject.files.length).to eq(1)
+      expect(subject.files.first.src).to  eq('noc_list.csv')
+      expect(subject.files.first.dest).to eq('input/noc_list.csv')
+    end
+
+    it 'sets fixtures' do
+      expect(subject.fixtures.length).to eq(2)
+      expect(subject.fixtures.first).to eq('iron_man')
+      expect(subject.fixtures.last).to  eq('hulk')
+    end
+  end
+end

data/spec/simmer/specification_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe Simmer::Specification do
+  let(:path) { File.join('specifications', 'load_noc_list.yaml') }
+
+  let(:config) { yaml_fixture(path).merge(path: path) }
+
+  describe 'initialization using acts_as_hashable' do
+    subject { described_class.make(config) }
+
+    it 'sets name' do
+      expect(subject.name).to eq('Declassify Users')
+    end
+
+    it 'sets path' do
+      expect(subject.path).to eq(path)
+    end
+  end
+end

data/spec/simmer/util/evaluator_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe Simmer::Util::Evaluator do
+  let(:template) do
+    'The {traits.speed} {animal} jumps over the {thing}.'
+  end
+
+  describe '#evaluate' do
+    context 'when input is hash with string keys' do
+      let(:input) do
+        {
+          'animal' => :fox,
+          'traits' => {
+            'speed' => :quick
+          },
+          'thing' => :wall
+        }
+      end
+
+      it 'renders template' do
+        expected = 'The quick fox jumps over the wall.'
+
+        expect(subject.evaluate(template, input)).to eq(expected)
+      end
+    end
+
+    context 'when input is hash with symbol keys' do
+      let(:input) do
+        {
+          animal: :fox,
+          traits: {
+            speed: :quick
+          },
+          thing: :wall
+        }
+      end
+
+      it 'renders template' do
+        expected = 'The quick fox jumps over the wall.'
+
+        expect(subject.evaluate(template, input)).to eq(expected)
+      end
+    end
+
+    context 'when input is OpenStruct' do
+      let(:input) do
+        OpenStruct.new(
+          animal: :fox,
+          traits: OpenStruct.new(
+            speed: :quick
+          ),
+          thing: :wall
+        )
+      end
+
+      it 'renders template' do
+        expected = 'The quick fox jumps over the wall.'
+
+        expect(subject.evaluate(template, input)).to eq(expected)
+      end
+    end
+
+    context 'when input is nil' do
+      let(:input) { nil }
+
+      it 'renders against nil' do
+        expected = 'The   jumps over the .'
+
+        expect(subject.evaluate(template, input)).to eq(expected)
+      end
+    end
+  end
+end

data/spec/simmer/util/record_set_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe Simmer::Util::RecordSet do
+  let(:hash1) do
+    {
+      a: 'a',
+      b: 'b'
+    }
+  end
+
+  let(:hash2) do
+    {
+      c: 'c',
+      d: 'd'
+    }
+  end
+
+  subject { described_class.new([hash1, hash2]) }
+
+  describe 'equality' do
+    specify 'hash order does not matter' do
+      subject2 = described_class.new([hash2, hash1])
+
+      expect(subject).to eq(subject2)
+      expect(subject).to eql(subject2)
+    end
+  end
+
+  specify '#keys includes all record keys' do
+    expect(subject.keys).to eq(%w[a b c d])
+  end
+end

data/spec/simmer/util/record_spec.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe Simmer::Util::Record do
+  describe 'initialization' do
+    let(:data) do
+      {
+        'a' => 'a'
+      }
+    end
+
+    it 'accepts hash' do
+      subject = described_class.new(data)
+
+      expect(subject.to_h).to eq(data)
+    end
+
+    it 'accepts Record' do
+      record  = Simmer::Util::Record.new(data)
+      subject = described_class.new(record)
+
+      expect(subject.to_h).to eq(data)
+    end
+
+    it 'accepts OpenStruct' do
+      record  = OpenStruct.new(data)
+      subject = described_class.new(record)
+
+      expect(subject.to_h).to eq(data)
+    end
+  end
+
+  describe 'equality' do
+    context 'when key types do not equal' do
+      let(:symbol_hash) do
+        {
+          '1': 1
+        }
+      end
+
+      let(:string_hash) do
+        {
+          '1' => 1
+        }
+      end
+
+      let(:numeric_hash) do
+        {}.tap do |hash|
+          hash[1] = 1
+        end
+      end
+
+      it 'compares symbol to string keys' do
+        record1 = described_class.new(symbol_hash)
+        record2 = described_class.new(string_hash)
+
+        expect(record1).to eq(record2)
+        expect(record1).to eql(record2)
+      end
+
+      it 'compares symbol to number keys' do
+        record1 = described_class.new(symbol_hash)
+        record2 = described_class.new(numeric_hash)
+
+        expect(record1).to eq(record2)
+        expect(record1).to eql(record2)
+      end
+
+      it 'compares string to number keys' do
+        record1 = described_class.new(string_hash)
+        record2 = described_class.new(numeric_hash)
+
+        expect(record1).to eq(record2)
+        expect(record1).to eql(record2)
+      end
+    end
+
+    context 'when value types do not equal' do
+      let(:symbol_hash) do
+        {
+          a: :'1'
+        }
+      end
+
+      let(:string_hash) do
+        {
+          a: '1'
+        }
+      end
+
+      let(:numeric_hash) do
+        {
+          a: 1
+        }
+      end
+
+      it 'compares symbol to string keys' do
+        record1 = described_class.new(symbol_hash)
+        record2 = described_class.new(string_hash)
+
+        expect(record1).to eq(record2)
+        expect(record1).to eql(record2)
+      end
+
+      it 'compares symbol to number keys' do
+        record1 = described_class.new(symbol_hash)
+        record2 = described_class.new(numeric_hash)
+
+        expect(record1).to eq(record2)
+        expect(record1).to eql(record2)
+      end
+
+      it 'compares string to number keys' do
+        record1 = described_class.new(string_hash)
+        record2 = described_class.new(numeric_hash)
+
+        expect(record1).to eq(record2)
+        expect(record1).to eql(record2)
+      end
+    end
+
+    context 'when keys and values are not in same order and mixed type' do
+      let(:alphabetical_hash) do
+        {
+          a: 'a',
+          b: :b,
+          'c': 'c'
+        }
+      end
+
+      let(:reverse_alphabetical_hash) do
+        {
+          b: 'b',
+          c: 'c',
+          'a': :a
+        }
+      end
+
+      it 'should ignore key ordering' do
+        record1 = described_class.new(alphabetical_hash)
+        record2 = described_class.new(reverse_alphabetical_hash)
+
+        expect(record1).to eq(record2)
+        expect(record1).to eql(record2)
+      end
+    end
+
+    context 'when value(s) are of type BigDecimal' do
+      let(:string_value) { '12.005' }
+
+      let(:float_hash) do
+        {
+          a: string_value.to_f
+        }
+      end
+
+      let(:big_decimal_hash) do
+        {
+          a: BigDecimal(string_value)
+        }
+      end
+
+      let(:string_hash) do
+        {
+          a: string_value
+        }
+      end
+
+      it 'compares floats with big decimals' do
+        record1 = described_class.new(float_hash)
+        record2 = described_class.new(big_decimal_hash)
+
+        expect(record1).to eq(record2)
+        expect(record1).to eql(record2)
+      end
+
+      it 'compares floats with strings' do
+        record1 = described_class.new(float_hash)
+        record2 = described_class.new(string_hash)
+
+        expect(record1).to eq(record2)
+        expect(record1).to eql(record2)
+      end
+
+      it 'compares big decimals with strings' do
+        record1 = described_class.new(big_decimal_hash)
+        record2 = described_class.new(string_hash)
+
+        expect(record1).to eq(record2)
+        expect(record1).to eql(record2)
+      end
+    end
+
+    it 'should not equal if values are not equal' do
+      record1 = described_class.new(a: 'a')
+      record2 = described_class.new(a: 'b')
+
+      expect(record1).not_to eq(record2)
+      expect(record1).not_to eql(record2)
+    end
+
+    it 'should not equal if keys are not equal' do
+      record1 = described_class.new(a: 'a')
+      record2 = described_class.new(b: 'a')
+
+      expect(record1).not_to eq(record2)
+      expect(record1).not_to eql(record2)
+    end
+  end
+end