pyper_rb 1.2.0

data/test/unit/pyper/pipes/cassandra/reader_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+module Pyper::Pipes::Cassandra
+  class ReaderTest < Minitest::Should::TestCase
+    context 'a cassandra reader pipe' do
+
+      setup do
+        setup_cass_schema
+
+        @client = create_cass_client('test_datastore')
+        @pipe = Reader.new(:test, @client)
+
+        # populate some test data
+        @client.insert(:test, {id: 'id', a: '1', b: 'b'})
+        @client.insert(:test, {id: 'id', a: '2', b: 'b'})
+      end
+
+      teardown do
+        teardown_cass_schema
+      end
+
+      should 'read items from the cassandra table' do
+        out = @pipe.pipe(id: 'id').to_a
+        assert_equal 2, out.count
+        assert_equal({ "id" => "id", "a" => "1", "b" => "b" }, out.first)
+      end
+
+      should 'return items in ascending order' do
+        out = @pipe.pipe(id: 'id').to_a
+        assert_equal %w(1 2), out.map { |i| i['a'] }
+      end
+
+      should 'limit results if limit arg provided' do
+        out = @pipe.pipe(id: 'id', :limit => 1).to_a
+        assert_equal 1, out.count
+      end
+
+      should 'order results by field and direction if order pair provided' do
+        out = @pipe.pipe(id: 'id', :order => [:a, :desc]).to_a
+        assert_equal %w(2 1), out.map { |i| i['a'] }
+      end
+
+      should 'save page state and last_page in status' do
+        status = {}
+        out = @pipe.pipe({id: 'id', :page_size => 1}, status).to_a
+        assert_equal 1, out.count
+        assert_equal '1', out.first['a']
+        assert status[:paging_state]
+        assert_equal false, status[:last_page]
+      end
+
+      should 'page through results if :page_size and/or :paging_state provided' do
+        status = {}
+        out = @pipe.pipe({id: 'id', :page_size => 1}, status).to_a
+        assert_equal 1, out.count
+        assert_equal '1', out.first['a']
+        paging_state = status[:paging_state]
+
+        out = @pipe.pipe({id: 'id', :page_size => 1, :paging_state => paging_state}, status).to_a
+        assert_equal 1, out.count
+        assert_equal '2', out.first['a']
+        assert_equal false, status[:last_page]
+      end
+
+      context "columns selecting" do
+        should "only select given columns from columns argument" do
+          out = @pipe.pipe({id: 'id', :columns => [:a]}).to_a
+          assert_equal({'a' => '1'}, out.first)
+          assert_equal({'a' => '2'}, out.last)
+        end
+
+        should  "select all columns when columns argument not given" do
+          out = @pipe.pipe({id: 'id'}).to_a
+          assert_equal({ "id" => "id", "a" => "1", "b" => "b" }, out.first)
+        end
+      end
+    end
+  end
+end

data/test/unit/pyper/pipes/cassandra/writer_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+module Pyper::Pipes::Cassandra
+  class WriterTest < Minitest::Should::TestCase
+    context 'a cassandra writer pipe' do
+
+      setup do
+        setup_cass_schema
+
+        @client = create_cass_client('test_datastore')
+        @writer = Writer.new(:test, @client)
+      end
+
+      teardown do
+        teardown_cass_schema
+      end
+
+      should 'write to the specified cassandra table' do
+        attributes = {id: 'id', a: 'a', b: 'b'}
+        @writer.pipe(attributes)
+        row = @client.select(:test).execute.first
+
+        attributes.keys.each do |key|
+          assert_equal attributes[key], row[key.to_s]
+        end
+      end
+
+      should 'raise an error if required attributes are not provided' do
+        attributes = {a: 'a', b: 'b'}
+        assert_raises(Cassandra::Errors::InvalidError) { @writer.pipe(attributes) }
+      end
+
+      should 'return the original attributes if the write succeeds' do
+        attributes = {id: 'id', a: 'a', b: 'b'}
+        assert_equal attributes, @writer.pipe(attributes)
+      end
+
+      should 'raise an error if too many attributes are provided' do
+        attributes = {id: 'id', a: 'a', b: 'b', not_an_attribute: 'x'}
+        assert_raises(Cassandra::Errors::InvalidError) { @writer.pipe(attributes) }
+      end
+
+      should 'filter attributes if a filter set is given, returning the original attributes' do
+        attributes = {id: 'id', a: 'a', b: 'b', not_an_attribute: 'x'}
+        filter = [:id, :a, :b]
+        writer = Writer.new(:test, @client, filter)
+        assert_equal attributes, writer.pipe(attributes)
+      end
+    end
+  end
+end

data/test/unit/pyper/pipes/content/fetch_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Pyper::Pipes::Content
+  class FetchTest < Minitest::Should::TestCase
+    context 'the content fetch pipe' do
+
+      setup do
+        @dir = Dir.mktmpdir
+        @storage_builder = lambda do |item|
+          StorageStrategy.get("#{@dir}/content",
+            filters: [:size, :checksum],
+            size: { metadata_key: :raw_size },
+            checksum: {
+              digest: :sha256,
+              hash_type: :hex,
+              metadata_key: :raw_sha256
+            })
+        end
+
+        @pipe = Fetch.new(:content, &@storage_builder)
+        @strategy = @storage_builder.call({})
+      end
+
+      should 'fetch content using the provided storage builder' do
+        content = 'asdf'
+        @strategy.write(content)
+
+        attributes = @pipe.pipe([{}])
+        assert_equal content, attributes.first[:content]
+      end
+
+      should 'add nothing if there is no content to store' do
+        attributes = @pipe.pipe([{}])
+        refute @content, attributes.first[:content]
+      end
+    end
+  end
+end

data/test/unit/pyper/pipes/content/store_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module Pyper::Pipes::Content
+  class StoreTest < Minitest::Should::TestCase
+    context 'the content storage pipe' do
+
+      setup do
+        @dir = Dir.mktmpdir
+        @storage_builder = lambda do |attributes|
+          StorageStrategy.get("#{@dir}/metadata",
+            filters: [:size, :checksum],
+            size: { metadata_key: :raw_size },
+            checksum: {
+              digest: :sha256,
+              hash_type: :hex,
+              metadata_key: :raw_sha256
+            })
+        end
+
+        @pipe = Store.new(:content, &@storage_builder)
+        @strategy = @storage_builder.call({})
+      end
+
+      should 'store content using the provided storage builder' do
+        content = 'asdf'
+        @pipe.pipe(:content => content)
+
+        assert_equal content, @strategy.read
+      end
+
+
+      should 'store size and checksum metadata' do
+        content = 'asdf'
+        @pipe.pipe(:content => content)
+
+        assert_equal '4', @strategy.metadata[:raw_size]
+        assert @strategy.metadata[:raw_sha256]
+      end
+
+      should 'remove content from attributes adding new metadata fields' do
+        content = 'asdf'
+        attributes = @pipe.pipe(:content => content)
+
+        assert_equal '4', attributes[:raw_size]
+        assert attributes[:raw_sha256]
+      end
+    end
+  end
+end

data/test/unit/pyper/pipes/field_rename_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Pyper::Pipes
+  class FieldRenameTest < Minitest::Should::TestCase
+    context 'the field rename pipe' do
+
+      setup do
+        @pipe = FieldRename.new(:a => :b, "c" => "d")
+      end
+
+      should 'rename provided symbols as symbols' do
+        assert_equal({ :b => 1, :d => 1}, @pipe.pipe(:a => 1, :c => 1))
+      end
+
+      should 'rename provided strings as strings' do
+        assert_equal({ "b" => 1, "d" => 1}, @pipe.pipe("a" => 1, "c" => 1))
+      end
+
+      should 'rename nil values' do
+        assert_equal({ :b => nil, "d" => nil}, @pipe.pipe(:a => nil, "c" => nil))
+      end
+    end
+  end
+end

data/test/unit/pyper/pipes/model/attribute_deserializer_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+require 'json'
+
+module Pyper::Pipes::Model
+  class AttributeDeserializerTest < Minitest::Should::TestCase
+    setup do
+      type_mapping = {
+                      :array => Array,
+                      :hash => Hash,
+                      :int => Integer,
+                      :float => Float,
+                      :other => String
+                     }
+      @pipe = AttributeDeserializer.new(type_mapping)
+    end
+
+    should 'deserialize json arrays' do
+      value = [1,2,3]
+      item = { :array => JSON.generate(value) }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first[:array]
+    end
+
+    should 'deserialize json hashes' do
+      value = {'a' => 1}
+      item = { :hash => JSON.generate(value) }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first[:hash]
+    end
+
+    should 'deserialize ints' do
+      value = 1
+      item = { :int => value.to_s }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first[:int]
+    end
+
+    should 'deserialize fixnums' do
+      value = 1.5
+      item = { :float => value.to_s }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first[:float]
+    end
+
+    should 'not deserialize other fields' do
+      value = 'asdf'
+      item = { :other => value }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first[:other]
+    end
+
+    should 'not modify original values when deserializng' do
+      value = [1,2,3]
+      item = { :array => JSON.generate(value) }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first[:array]
+
+      # This throws an error if we have modified the original values
+      out = @pipe.pipe([item])
+      assert_equal value, out.first[:array]
+    end
+  end
+end

data/test/unit/pyper/pipes/model/attribute_serializer_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+require 'json'
+
+module Pyper::Pipes::Model
+  class AttributeSerializerTest < Minitest::Should::TestCase
+    setup do
+      @pipe = AttributeSerializer.new
+    end
+
+    should 'serialize arrays to JSON' do
+      value = [1,2,3]
+      attributes = { :array => value }
+      out = @pipe.pipe(attributes)
+      assert_equal 1, out.count
+      assert_equal JSON.generate(value), out[:array]
+    end
+
+    should 'serialize hashes to JSON' do
+      value = {'a' => 1}
+      attributes = { :hash => value }
+      out = @pipe.pipe(attributes)
+      assert_equal 1, out.count
+      assert_equal JSON.generate(value), out[:hash]
+    end
+
+    should 'serialize datetimes to times' do
+      value = DateTime.now
+      attributes = { :datetime => value }
+      out = @pipe.pipe(attributes)
+      assert_equal 1, out.count
+      assert_equal value.to_time, out[:datetime]
+    end
+
+    should 'encode strings to utf-8' do
+      value = 'str'.force_encoding('ascii-8bit')
+      attributes = { :string => value }
+      out = @pipe.pipe(attributes)
+      assert_equal 1, out.count
+      assert_equal Encoding::UTF_8, out[:string].encoding
+    end
+
+    should 'be able to serialize collections containing strings with non-UTF8 characters to JSON' do
+      ascii = "\xC2\xA0".force_encoding('ascii-8bit')
+      time = DateTime.now
+      ascii_values = { :array => [ascii], :datetime => time, :fixnum => 1, :string => ascii }
+      utf8_values = { :array => [ascii.force_encoding("UTF-8")], :datetime => time, :fixnum => 1, :string => ascii.force_encoding("UTF-8") }
+      out = @pipe.pipe({ :hash => ascii_values })
+      assert_equal 1, out.count
+      assert_equal JSON.generate(utf8_values), out[:hash]
+    end
+
+    should 'not serialize other fields' do
+      value = 1.5
+      attributes = { :fixnum => value }
+      out = @pipe.pipe(attributes)
+      assert_equal 1, out.count
+      assert_equal value, out[:fixnum]
+    end
+  end
+end

data/test/unit/pyper/pipes/model/attribute_validation_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+module Pyper::Pipes::Model
+  class AttributeValidationTest < Minitest::Should::TestCase
+    context "pipe" do
+      context "with required attributes" do
+        setup do
+          @opts = { :required => [:foo, :bar] }
+          @pipe = AttributeValidation.new(@opts)
+        end
+
+        should "raise when missing required attribute" do
+          error_1 = assert_raises(AttributeValidation::Failure) do
+            @pipe.pipe({})
+          end
+          assert_equal "Missing required attribute foo.", error_1.message
+
+          error_2 = assert_raises(AttributeValidation::Failure) do
+            @pipe.pipe({ :foo => "bar" })
+          end
+          assert_equal "Missing required attribute bar.", error_2.message
+
+          # Nothing should be raised now.
+          @pipe.pipe({ :foo => "bar", :bar => "qux" })
+        end
+
+        should "raise when required attribute is nil" do
+          error = assert_raises(AttributeValidation::Failure) do
+            @pipe.pipe({ :foo => nil, :bar => "qux"})
+          end
+          assert_equal "Missing required attribute foo.", error.message
+        end
+      end
+
+      context "with allowed attributes" do
+        setup do
+          @opts = { :allowed => [:foo, :bar] }
+          @pipe = AttributeValidation.new(@opts)
+        end
+
+        should "raise when attribute is not included in the whitelist" do
+          error = assert_raises(AttributeValidation::Failure) do
+            @pipe.pipe({ :foo => "foo", :bar => "bar", :baz => "baz" })
+          end
+          assert_equal "Attribute baz is not allowed.", error.message
+
+          # Nothing should be raised now.
+          @pipe.pipe({ :foo => "foo", :bar => "bar" })
+        end
+
+        should "allow all attributes when allowed option is not set" do
+          pipe = AttributeValidation.new
+
+          # Nothing should be raised now.
+          pipe.pipe({ :foo => "foo", :bar => "bar", :baz => "baz" })
+        end
+      end
+
+
+      context "with restricted attributes" do
+        setup do
+          @opts = {
+            :restricted => {
+              :bar => lambda { |value| ["qux", "bazqux"].include?(value) }
+            }
+          }
+          @pipe = AttributeValidation.new(@opts)
+        end
+
+        should "raise when lambda returns false" do
+          error = assert_raises(AttributeValidation::Failure) do
+            @pipe.pipe({ :bar => "foo"})
+          end
+          assert_equal "Invalid value for attribute bar.", error.message
+
+          # Nothing should be raised now.
+          @pipe.pipe({ :bar => "qux" })
+          @pipe.pipe({ :bar => "bazqux" })
+        end
+      end
+
+      should "return attributes hash when all is well" do
+        opts = {
+          :allowed => [:foo, :bar],
+          :required => [:foo],
+          :restricted => {
+            :bar => lambda { |value| ["bar", "foobar"].include?(value) }
+          }
+        }
+        pipe = AttributeValidation.new(opts)
+        attributes = { :foo => "bar", :bar => "foobar" }
+        assert_equal attributes, pipe.pipe(attributes)
+      end
+    end
+  end
+end

data/test/unit/pyper/pipes/model/virtus_deserializer_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+require 'json'
+require 'virtus'
+
+module Pyper::Pipes::Model
+  class VirtusDeserializerTest < Minitest::Should::TestCase
+
+    class TestVirtus
+      include ::Virtus.model
+
+      attribute :array, Array[String]
+      attribute :hash, Hash
+      attribute :int, Integer
+      attribute :float, Float
+      attribute :other, String
+    end
+
+    setup do
+      @pipe = VirtusDeserializer.new(TestVirtus.attribute_set)
+    end
+
+    should 'deserialize json arrays' do
+      value = [1,2,3]
+      item = { 'array' => JSON.generate(value) }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+
+      assert_equal value, out.first['array']
+    end
+
+    should 'deserialize json hashes' do
+      value = {'a' => 1}
+      item = { 'hash' => JSON.generate(value) }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first['hash']
+    end
+
+    should 'deserialize ints' do
+      value = 1
+      item = { 'int' => value.to_s }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first['int']
+    end
+
+    should 'deserialize floats' do
+      value = 1.5
+      item = { 'float' => value.to_s }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first['float']
+    end
+
+    should 'not deserialize other fields' do
+      value = 'asdf'
+      item = { 'other' => value }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first['other']
+    end
+
+    should 'not modify original values when deserializng' do
+      value = [1,2,3]
+      item = { 'array' => JSON.generate(value) }
+      out = @pipe.pipe([item])
+      assert_equal 1, out.count
+      assert_equal value, out.first['array']
+
+      # This throws an error if we have modified the original values
+      out = @pipe.pipe([item])
+      assert_equal value, out.first['array']
+    end
+  end
+end

data/test/unit/pyper/pipes/no_op_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+module Pyper::Pipes
+  class NoOpTest < Minitest::Should::TestCase
+    context 'NoOp pipe' do
+      should 'perform no operation' do
+        pipe_input = { :pipe_var => "this is a string" }
+        assert_equal pipe_input, NoOp.pipe(pipe_input)
+      end
+    end
+  end
+end

data/test/unit/pyper/pipes/remove_fields_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Pyper::Pipes
+  class RemoveFieldsTest < Minitest::Should::TestCase
+    context 'the remove fields pipe' do
+
+      should "accept a symbol" do
+        pipe = RemoveFields.new(:a)
+        assert_equal({ :b => 2 }, pipe.pipe(:a => 1, :b => 2))
+      end
+
+      should "accept an array of  symbol" do
+        pipe = RemoveFields.new([:a])
+        assert_equal({ :b => 2 }, pipe.pipe(:a => 1, :b => 2))
+      end
+
+      should 'remove fields provided an array of symbols' do
+        pipe = RemoveFields.new([:a])
+        assert_equal({ :b => 2 }, pipe.pipe(:a => 1, :b => 2))
+      end
+
+    end
+  end
+end