tentd 0.0.1

data/spec/unit/core_profile_data_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe TentD::API::CoreProfileData do
+  let(:tent_profile_type_uri) { "https://tent.io/types/info/core/v0.1.0" }
+  let(:entity_url) { "https://smith.example.com" }
+  let(:another_entity_url) { "https://alex.example.org" }
+  let(:data) do
+    {
+      "https://tent.io/types/info/core/v0.1.5" => {
+        "licenses" => [],
+        "entity" => entity_url,
+      },
+      "https://tent.io/types/info/core/v0.1.1" => {
+        "licenses" => [],
+        "entity" => entity_url,
+      },
+      "https://tent.io/types/info/core/v0.2.0" => {
+        "licenses" => [],
+        "entity" => entity_url,
+      },
+      "https://tent.io/types/info/musci/v0.1.0" => {
+      }
+    }
+  end
+  describe '#expected_version' do
+    it 'should return TentVersion representing sever tent profile type uri version' do
+      with_constants "TentD::Model::ProfileInfo::TENT_PROFILE_TYPE_URI" => tent_profile_type_uri do
+        expect(described_class.new(data).expected_version).to eq(TentD::TentVersion.new('0.1.0'))
+      end
+    end
+  end
+
+  describe '#versions' do
+    it 'should return array of TentVersions found in data matching core info type' do
+      expect(described_class.new(data).versions).to eq([
+        TentD::TentVersion.new('0.1.1'),
+        TentD::TentVersion.new('0.1.5'),
+        TentD::TentVersion.new('0.2.0')
+      ])
+    end
+  end
+
+  describe '#version' do
+    it 'should return closest compatible version' do
+      expect(described_class.new(data).version).to eq(TentD::TentVersion.new('0.1.1'))
+    end
+  end
+
+  describe '#version_key' do
+    it 'should return full url of version' do
+      expect(described_class.new(data).version_key).to eq("https://tent.io/types/info/core/v0.1.1")
+    end
+  end
+
+  describe '#entity?(entity)' do
+    it 'should return true if entity matches' do
+      expect(described_class.new(data).entity?(entity_url)).to be_true
+    end
+
+    it 'should return false if entity does not match' do
+      expect(described_class.new(data).entity?(another_entity_url)).to be_false
+    end
+  end
+end

data/spec/unit/json_patch_spec.rb

@@ -0,0 +1,407 @@
+require 'spec_helper'
+
+describe TentD::JsonPatch::HashPointer do
+  context 'when finding pointer' do
+    it 'should find nested hash' do
+      hash = { "a" => { "b" => { "c" => "foo" } } }
+      pointer = described_class.new(hash, "a/b/c")
+      expect(pointer.value).to eq("foo")
+    end
+
+    it 'should find position in array' do
+      hash = { "a" => ["foo", "bar", "baz"] }
+      pointer = described_class.new(hash, "a/1")
+      expect(pointer.value).to eq("bar")
+    end
+
+    it "should throw exception if key doesn't exist" do
+      hash = { "a" => "foo" }
+      pointer = described_class.new(hash, "a/b/c")
+      expect(lambda { pointer.value }).to raise_error(described_class::InvalidPointer)
+    end
+
+    it "should throw exception if array position is outsize index range" do
+      hash = { "a" => ["foo", "bar", "baz"] }
+      pointer = described_class.new(hash, "a/3")
+      expect(lambda { pointer.value }).to raise_error(described_class::InvalidPointer)
+    end
+  end
+
+  context 'when setting pointer' do
+    it "should set nested hash key" do
+      pointer = described_class.new({}, "a/b/c")
+      pointer.value = "foo"
+      expect(pointer.value).to eq("foo")
+    end
+
+    it 'should set value at array index' do
+      hash = { "a" => ["foo", "bar"] }
+      pointer = described_class.new(hash, "a/1")
+      pointer.value = "baz"
+      expect(hash["a"]).to be_an(Array)
+      expect(pointer.value).to eq("baz")
+      expect(described_class.new(hash, "a/2").value).to eq("bar")
+
+      hash = { "a" => { "b" =>  ["foo", "baz"] } }
+      pointer = described_class.new(hash, "a/b/1")
+      pointer.value = "bar"
+      expect(hash["a"]["b"]).to be_an(Array)
+      expect(pointer.value).to eq("bar")
+    end
+  end
+
+  context 'when deleting pointer' do
+    it 'should delete key from object' do
+      hash = { "a" => { "b" => { "c" => "foo" } } }
+      pointer = described_class.new(hash, "a/b/c")
+      pointer.delete
+      expect(hash).to eq({ "a" => { "b" => {} } })
+    end
+
+    it 'should delete index from array' do
+      hash = { "a" => { "b" => ["foo", "baz", "bar"] } }
+      pointer = described_class.new(hash, "a/b/1")
+      pointer.delete
+      expect(hash).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+
+    it 'should throw exception if key does not exist' do
+      hash = {}
+      pointer = described_class.new(hash, "a")
+      expect( lambda { pointer.delete }).to raise_error(described_class::InvalidPointer)
+      expect(hash).to eq({})
+    end
+
+    it 'should throw exception if index of array does not exist' do
+      hash = { "a" => { "b" => ["foo", "bar"] } }
+      pointer = described_class.new(hash, "a/b/2")
+      expect( lambda { pointer.delete }).to raise_error(described_class::InvalidPointer)
+      expect(hash).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+  end
+
+  context 'when moving pointer' do
+    it 'should move key to another key' do
+      hash = { "a" => { "b" => { "c" => "foo" } } }
+      pointer = described_class.new(hash, "a/b")
+      pointer.move_to "/b"
+      expect(hash).to eq({ "a" => {}, "b" => { "c" => "foo" } })
+    end
+
+    it 'should move array index to another index' do
+      hash = { "a" => { "b" => ["foo", "bar"] } }
+      pointer = described_class.new(hash, "a/b/0")
+      pointer.move_to "a/b/1"
+      expect(hash).to eq({ "a" => { "b" => ["bar", "foo"] } })
+    end
+
+    it 'should throw exception if to would overwrite another key' do
+      hash = { "a" => { "b" => ["foo", "bar"] } }
+      pointer = described_class.new(hash, "a/b/0")
+      expect( lambda { pointer.move_to "a/b/c" } ).
+        to raise_error(described_class::InvalidPointer)
+      expect(hash).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+  end
+
+  describe '#exists?' do
+    it 'should return false if key not in hash' do
+      hash = { "a" => { "b" =>  { "foo" => "bar" } } }
+      pointer = described_class.new(hash, "a/b/c")
+      expect(pointer.exists?).to be_false
+    end
+
+    it 'should return false if index not in array' do
+      hash = { "a" => { "b" => ["foo", "bar"] } }
+      pointer = described_class.new(hash, "a/b/2")
+      expect(pointer.exists?).to be_false
+    end
+
+    it 'should return true if key in hash' do
+      hash = { "a" => { "b" =>  { "foo" => "bar" } } }
+      pointer = described_class.new(hash, "a/b")
+      expect(pointer.exists?).to be_true
+
+      hash = { "a" => "baz" }
+      pointer = described_class.new(hash, "a/b")
+      expect(pointer.exists?).to be_true
+    end
+
+    it 'should return true if index in array' do
+      hash = { "a" => { "b" => ["foo", "bar"] } }
+      pointer = described_class.new(hash, "a/b/1")
+      expect(pointer.exists?).to be_true
+    end
+  end
+end
+
+describe TentD::JsonPatch do
+  describe 'add' do
+    it 'should add new value at specified location' do
+      object = {}
+      patch_object = [{ "add" => "a/b/c", "value" => ["foo", "bar", "baz"] }]
+      TentD::JsonPatch.merge(object, patch_object)
+      expect(object).to be_a(Hash)
+      expect(object["a"]["b"]["c"]).to eq(["foo", "bar", "baz"])
+
+      object = { "a" => {} }
+      patch_object = [{ "add" => "a/b/c", "value" => ["foo", "bar", "baz"] }]
+      TentD::JsonPatch.merge(object, patch_object)
+      expect(object).to be_a(Hash)
+      expect(object["a"]["b"]["c"]).to eq(["foo", "bar", "baz"])
+
+      object = { "a" => { "b" => {} } }
+      patch_object = [{ "add" => "a/b/c", "value" => ["foo", "bar", "baz"] }]
+      TentD::JsonPatch.merge(object, patch_object)
+      expect(object).to be_a(Hash)
+      expect(object["a"]["b"]["c"]).to eq(["foo", "bar", "baz"])
+    end
+
+    it 'should throw exception if specified location exists' do
+      object = { "a" => "foo" }
+      patch_object = [{ "add" => "a/b/c", "value" => ["foo", "bar", "baz"] }]
+      expect( lambda { TentD::JsonPatch.merge(object, patch_object) } ).
+        to raise_error(described_class::ObjectExists)
+      expect(object["a"]).to eq("foo")
+
+      object = { "a" => { "b" => "foo" } }
+      patch_object = [{ "add" => "a/b/c", "value" => ["foo", "bar", "baz"] }]
+      expect( lambda { TentD::JsonPatch.merge(object, patch_object) } ).
+        to raise_error(described_class::ObjectExists)
+      expect(object["a"]).to eq("b" => "foo")
+
+      object = { "a" => { "b" => { "c" => "foo" } } }
+      patch_object = [{ "add" => "a/b/c", "value" => ["foo", "bar", "baz"] }]
+      expect( lambda { TentD::JsonPatch.merge(object, patch_object) } ).
+        to raise_error(described_class::ObjectExists)
+      expect(object["a"]).to eq("b" => { "c" => "foo" })
+
+      object = { "a" => { "b" => { "c" => "foo" } } }
+      patch_object = [{ "add" => "a/b/c/d/e/f/g", "value" => ["foo", "bar", "baz"] }]
+      expect( lambda { TentD::JsonPatch.merge(object, patch_object) } ).
+        to raise_error(described_class::ObjectExists)
+      expect(object["a"]).to eq("b" => { "c" => "foo" })
+
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "add" => "a/b/c/d/e/f/g", "value" => ["foo", "bar", "baz"] }]
+      expect( lambda { TentD::JsonPatch.merge(object, patch_object) } ).
+        to raise_error(described_class::ObjectExists)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+
+    context 'when pointer is an array' do
+      it 'should add new value at specified index' do
+        object = { "a" => ["foo", "bar"] }
+        patch_object = [{ "add" => "a/1", "value" => "baz" }]
+        TentD::JsonPatch.merge(object, patch_object)
+        expect(object["a"]).to eq(["foo", "baz", "bar"])
+      end
+    end
+  end
+
+  describe 'remove' do
+    it 'should remove specified key' do
+      object = { "a" => { "b" => { "c" => "foo" } } }
+      patch_object = [{ "remove" => "a/b/c" }]
+      described_class.merge(object, patch_object)
+      expect(object).to eq({ "a" => { "b" => {} } })
+    end
+
+    it 'should throw exception if specified key does not exist' do
+      object = { "a" => { "b" => {} } }
+      patch_object = [{ "remove" => "a/b/c" }]
+      expect( lambda { described_class.merge(object, patch_object) } ).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => {} } })
+    end
+
+    context 'when pointer is an array' do
+      it 'should remove specified index' do
+        object = { "a" => { "b" => ["foo", "baz", "bar"] } }
+        patch_object = [{ "remove" => "a/b/1" }]
+        described_class.merge(object, patch_object)
+        expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+      end
+
+      it 'should throw exception if specified index does not exist' do
+        object = { "a" => { "b" => ["foo"] } }
+        patch_object = [{ "remove" => "a/b/1" }]
+        expect( lambda { described_class.merge(object, patch_object) } ).
+          to raise_error(described_class::ObjectNotFound)
+        expect(object).to eq({ "a" => { "b" => ["foo"] } })
+      end
+    end
+  end
+
+  describe 'replace' do
+    it 'should replace specified key value' do
+      object = { "a" => { "b" => { "c" => "foo" } } }
+      patch_object = [{ "replace" => "a", "value" => ["foo", "bar"] }]
+      described_class.merge(object, patch_object)
+      expect(object).to eq({ "a" => ["foo", "bar"] })
+    end
+
+    it 'should replace specified index of array' do
+      object = { "a" => { "b" => ["foo", "baz"] } }
+      patch_object = [{ "replace" => "a/b/1", "value" => "bar" }]
+      described_class.merge(object, patch_object)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+
+    it 'should throw exception if specified key does not exist' do
+      object = { "a" => { "b" => {} } }
+      patch_object = [{ "replace" => "a/b/c", "value" => "foo" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => {} } })
+    end
+
+    it 'should throw exception if specified index does not exist' do
+      object = { "a" => [] }
+      patch_object = [{ "replace" => "a/1", "value" => "bar" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => [] })
+    end
+  end
+
+  describe 'move' do
+    it 'should move specified key to new key' do
+      object = { "a" => { "b" => { "c" => "foo" } } }
+      patch_object = [{ "move" => "a/b", "to" => "/b" }]
+      described_class.merge(object, patch_object)
+      expect(object).to eq({ "a" => {}, "b" => { "c" => "foo" } })
+    end
+
+    it 'should move specified index to new index' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "move" => "a/b/0", "to" => "a/b/1" }]
+      described_class.merge(object, patch_object)
+      expect(object).to eq({ "a" => { "b" => ["bar", "foo"] } })
+    end
+
+    it 'should throw exception if specified key does not exist' do
+      object = { "a" => { "b" => { "c" => "foo" } } }
+      patch_object = [{ "move" => "a/b/c/d", "to" => "/b" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => { "c" => "foo" } } })
+
+      object = { "a" => { "b" => "foo" } }
+      patch_object = [{ "move" => "a/b/c", "to" => "a" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => "foo" } })
+    end
+
+    it 'should throw exception if specified index does not exist' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "move" => "a/b/2", "to" => "a/b/0" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+
+    it 'should throw exception if to key would overwrite another' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "move" => "a/b/0", "to" => "a/b/c" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+  end
+
+  describe 'copy' do
+    it 'should copy specified key value to new key' do
+      object = { "a" => { "b" => { "c" => "foo" } } }
+      patch_object = [{ "copy" => "a/b/c", "to" => "/c" }]
+      described_class.merge(object, patch_object)
+      expect(object).to eq({ "a" => { "b" => { "c" => "foo" } }, "c" => "foo" })
+    end
+
+    it 'should copy specified index value to new index' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "copy" => "a/b/0", "to" => "a/b/2" }]
+      described_class.merge(object, patch_object)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar", "foo"] } })
+    end
+
+    it 'should throw exception if specified key does not exist' do
+      object = { "a" => { "b" => { "c" => "foo" } } }
+      patch_object = [{ "copy" => "a/b/c/d", "to" => "/b" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => { "c" => "foo" } } })
+
+      object = { "a" => { "b" => "foo" } }
+      patch_object = [{ "copy" => "a/b/c", "to" => "a" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => "foo" } })
+    end
+
+    it 'should throw exception if specified index does not exist' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "copy" => "a/b/2", "to" => "a/b/0" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+
+    it 'should throw exception if to key would overwrite another' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "copy" => "a/b/0", "to" => "a/b/c" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectExists)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+  end
+
+  describe 'test' do
+    it 'should throw exception if specified key does not exist' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "test" => "a/c" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+
+    it 'should throw exception if specified key does not equal specified value' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "test" => "a/b/0", "value" => "chunkybacon" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+
+    it 'should throw exception if specified index does not exist' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "test" => "a/b/3" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+
+    it 'should throw exception if specified index does not equal specified value' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "test" => "a/b/0", "value" => "chunkybacon" }]
+      expect(lambda { described_class.merge(object, patch_object) }).
+        to raise_error(described_class::ObjectNotFound)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+
+    it 'should not do anything if key exists and matches specified value' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "test" => "a/b", "value" => ["foo", "bar"] }]
+      described_class.merge(object, patch_object)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+
+    it 'should not do anything if index exists and matches specified value' do
+      object = { "a" => { "b" => ["foo", "bar"] } }
+      patch_object = [{ "test" => "a/b/0", "value" => "foo" }]
+      described_class.merge(object, patch_object)
+      expect(object).to eq({ "a" => { "b" => ["foo", "bar"] } })
+    end
+  end
+end