schemata-dea 0.0.1.beta1

data/spec/component/foo_spec.rb

@@ -0,0 +1,214 @@
+require 'schemata/component/foo'
+require 'schemata/common/error'
+require 'support/helpers'
+
+describe Schemata::Component::Foo do
+  describe "V10" do
+    it "should define accessors for the schema" do
+      v10_obj = Schemata::Component::Foo::V10.new
+      v10_obj.respond_to?(:foo1).should be_true
+      v10_obj.respond_to?(:foo1=).should be_true
+      v10_obj.respond_to?(:foo2).should be_true
+      v10_obj.respond_to?(:foo2=).should be_true
+    end
+
+    it "should not raise an error if an incomplete but valid hash is given" do
+      v10_hash = {"foo1" => "foo"}
+      expect { Schemata::Component::Foo::V10.new(v10_hash) }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete and invalid hash is given" do
+      v10_hash = {"foo1" => 1}
+      expect {
+        Schemata::Component::Foo::V10.new(v10_hash)
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an attribute is correctly assigned" do
+      foo_obj = Schemata::Component.mock_foo 10
+      expect { foo_obj.foo1 = "new name" }.to_not raise_error
+    end
+
+    it "should raise an error if an attribute is incorrectly assigned" do
+      foo_obj = Schemata::Component.mock_foo 10
+      expect { foo_obj.foo1 = 1 }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an incomplete msg_obj is updated \
+correctly" do
+      v10_hash = {"foo1" => "foo"}
+      v10_obj = Schemata::Component::Foo::V10.new(v10_hash)
+      expect { v10_obj.foo1 = "new name" }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete msg_obj is updated \
+incorrectly" do
+      v10_hash = {"foo1" => "foo"}
+      v10_obj = Schemata::Component::Foo::V10.new(v10_hash)
+      expect { v10_obj.foo1 = 1 }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+
+  describe "V11" do
+    it "should define accessors for the schema" do
+      v11_obj = Schemata::Component::Foo::V11.new
+      v11_obj.respond_to?(:foo1).should be_true
+      v11_obj.respond_to?(:foo1=).should be_true
+      v11_obj.respond_to?(:foo2).should be_true
+      v11_obj.respond_to?(:foo2=).should be_true
+      v11_obj.respond_to?(:foo3).should be_true
+      v11_obj.respond_to?(:foo3=).should be_true
+    end
+
+    it "should not raise an error if an incomplete but valid hash is given" do
+      v11_hash = {"foo1" => "foo"}
+      expect { Schemata::Component::Foo::V11.new(v11_hash) }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete and invalid hash is given" do
+      v11_hash = {"foo1" => 1}
+      expect {
+        v11_obj = Schemata::Component::Foo::V11.new(v11_hash)
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an attribute is correctly assigned" do
+      foo_obj = Schemata::Component.mock_foo 11
+      expect { foo_obj.foo2 = 10 }.to_not raise_error
+    end
+
+    it "should raise an error if an attribute is incorrectly assigned" do
+      foo_obj = Schemata::Component.mock_foo 11
+      expect {
+        foo_obj.foo2 = "foo"
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an incomplete msg_obj is updated \
+correctly" do
+      v11_hash = {"foo1" => "foo"}
+      v11_obj = Schemata::Component::Foo::V11.new(v11_hash)
+      expect { v11_obj.foo1 = "new name" }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete msg_obj is updated \
+incorrectly" do
+      v11_hash = {"foo1" => "foo"}
+      v11_obj = Schemata::Component::Foo::V11.new(v11_hash)
+      expect {
+        v11_obj.foo1 = 1
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+
+  describe "V12" do
+    it "should define accessors for the schema" do
+      v12_obj = Schemata::Component::Foo::V12.new
+      v12_obj.respond_to?(:foo1).should be_true
+      v12_obj.respond_to?(:foo1=).should be_true
+      v12_obj.respond_to?(:foo2).should be_true
+      v12_obj.respond_to?(:foo2=).should be_true
+      v12_obj.respond_to?(:foo3).should be_true
+      v12_obj.respond_to?(:foo3=).should be_true
+    end
+
+    it "should not raise an error if an incomplete but valid hash is given" do
+      v12_hash = {"foo1" => "foo"}
+      expect { Schemata::Component::Foo::V12.new(v12_hash) }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete and invalid hash is given" do
+      v12_hash = {"foo1" => 1}
+      expect {
+        Schemata::Component::Foo::V12.new(v12_hash)
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an attribute is correctly assigned" do
+      foo_obj = Schemata::Component.mock_foo 12
+      expect { foo_obj.foo3 = [1, 2] }.to_not raise_error
+    end
+
+    it "should raise an error if an attribute is incorrectly assigned" do
+      foo_obj = Schemata::Component.mock_foo 12
+      expect {
+        foo_obj.foo3 = 1
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an incomplete msg_obj is updated \
+correctly" do
+      v12_hash = {"foo1" => "foo"}
+      v12_obj = Schemata::Component::Foo::V12.new(v12_hash)
+      expect { v12_obj.foo1 = "new name" }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete msg_obj is updated \
+incorrectly" do
+      v12_hash = {"foo1" => "foo"}
+      v12_obj = Schemata::Component::Foo::V12.new(v12_hash)
+      expect {
+        v12_obj.foo1 = 1
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+
+  describe "V13" do
+    it "should define accessors for the schema" do
+      v13_obj = Schemata::Component::Foo::V13.new
+      v13_obj.respond_to?(:foo1).should be_true
+      v13_obj.respond_to?(:foo1=).should be_true
+      v13_obj.respond_to?(:foo3).should be_true
+      v13_obj.respond_to?(:foo3=).should be_true
+      v13_obj.respond_to?(:foo4).should be_true
+      v13_obj.respond_to?(:foo4=).should be_true
+    end
+
+    it "should not raise an error if an incomplete but valid hash is given" do
+      v13_hash = {"foo1" => "foo"}
+      expect { Schemata::Component::Foo::V13.new(v13_hash) }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete and invalid hash is given" do
+      v13_hash = {"foo1" => 1}
+      expect {
+        Schemata::Component::Foo::V13.new(v13_hash)
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an attribute is correctly assigned" do
+      foo_obj = Schemata::Component.mock_foo 13
+      expect { foo_obj.foo4 = "foobar" }.to_not raise_error
+    end
+
+    it "should raise an error if an attribute is incorrectly assigned" do
+      foo_obj = Schemata::Component.mock_foo 13
+      expect {
+        foo_obj.foo4 =1
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should raise an error if an accessed field was removed" do
+      foo_obj = Schemata::Component.mock_foo 13
+      expect {
+        foo_obj.foo2
+      }.to raise_error
+    end
+
+    it "should not raise an error if an incomplete msg_obj is updated \
+correctly" do
+      v13_hash = {"foo1" => "foo"}
+      v13_obj = Schemata::Component::Foo::V13.new(v13_hash)
+      expect { v13_obj.foo1 = "new name" }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete msg_obj is updated \
+incorrectly" do
+      v13_hash = {"foo1" => "foo"}
+      v13_obj = Schemata::Component::Foo::V13.new(v13_hash)
+      expect {
+        v13_obj.foo1 = 1
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+end

data/spec/dea/advertise_message_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::AdvertiseMessage do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::AdvertiseMessage::V1 do
+  it_behaves_like "a message"
+end

data/spec/dea/dea_spec.rb

@@ -0,0 +1,6 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA do
+  it_behaves_like "a schemata component"
+end

data/spec/dea/dea_status_response_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::DropletStatusResponse do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::DropletStatusResponse::V1 do
+  it_behaves_like "a message"
+end

data/spec/dea/discover_request_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::DiscoverRequest do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::DiscoverRequest::V1 do
+  it_behaves_like "a message"
+end

data/spec/dea/droplet_status_response_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::DropletStatusResponse do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::DropletStatusResponse::V1 do
+  it_behaves_like "a message"
+end

data/spec/dea/exit_message_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::ExitMessage do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::ExitMessage::V1 do
+  it_behaves_like "a message"
+end

data/spec/dea/find_droplet_request_spec.rb

@@ -0,0 +1,27 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::FindDropletRequest do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::FindDropletRequest::V1 do
+  it_behaves_like "a message"
+
+  it "should stringify the 'states' field when it is given to the constructor as a symbol" do
+    hash = {
+      "droplet" => "deadbeef",
+      "states" => [:RUNNING],
+      "version" => "0.1.0",
+    }
+
+    msg_obj = Schemata::DEA::FindDropletRequest::V1.new(hash)
+    msg_obj.states.should =~ ["RUNNING"]
+  end
+
+  it "should stringify the 'states' field when a symbold is passed ot the attr writer" do
+    msg_obj = Schemata::DEA.mock_find_droplet_request
+    msg_obj.states = [:RUNNING]
+    msg_obj.states.should =~ ["RUNNING"]
+  end
+end

data/spec/dea/find_droplet_response_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::FindDropletResponse do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::FindDropletResponse::V1 do
+  it_behaves_like "a message"
+end

data/spec/dea/heartbeat_response_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::HeartbeatResponse do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::HeartbeatResponse::V1 do
+  it_behaves_like "a message"
+end

data/spec/dea/hello_message_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::HelloMessage do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::HelloMessage::V1 do
+  it_behaves_like "a message"
+end

data/spec/dea/start_request_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::StartRequest do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::StartRequest::V1 do
+  it_behaves_like "a message"
+end

data/spec/dea/stop_request_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::DEA::StopRequest do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::DEA::StopRequest::V1 do
+  it_behaves_like "a message"
+end

data/spec/router/register_request_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/router'
+require 'spec_helper'
+
+describe Schemata::Router::RegisterRequest do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::Router::RegisterRequest::V1 do
+  it_behaves_like "a message"
+end

data/spec/router/router_spec.rb

@@ -0,0 +1,6 @@
+require 'schemata/router'
+require 'spec_helper'
+
+describe Schemata::Router do
+  it_behaves_like "a schemata component"
+end

data/spec/router/start_message_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/router'
+require 'spec_helper'
+
+describe Schemata::Router::StartMessage do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::Router::StartMessage::V1 do
+  it_behaves_like "a message"
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }

data/spec/staging/staging_message_spec.rb

@@ -0,0 +1,14 @@
+require 'schemata/staging'
+require 'spec_helper'
+
+describe Schemata::Staging::Message do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::Staging::Message::V1 do
+  it_behaves_like "a message"
+end
+
+describe Schemata::Staging::Message::V2 do
+  it_behaves_like "a message"
+end

data/spec/staging/staging_spec.rb

@@ -0,0 +1,6 @@
+require 'schemata/staging'
+require 'spec_helper'
+
+describe Schemata::Staging do
+  it_behaves_like "a schemata component"
+end

data/spec/support/component_helpers.rb

@@ -0,0 +1,51 @@
+require 'support/helpers'
+
+shared_examples "a schemata component" do
+
+  described_class.constants.select { |x| x != :VERSION }.each do |msg_type|
+    describe ".mock_#{decamelize(msg_type.to_s)}" do
+      versions = described_class::const_get(msg_type).constants.select { |x| x =~ /V[0-9]+/ }
+      versions.map { |x| x = x.to_s[1..-1].to_i }.each do |version|
+        it_behaves_like "a mocking method", version do
+          let(:message_type)      { described_class::const_get(msg_type) }
+          let(:message_type_name) { msg_type.to_s }
+          let(:component)         { described_class }
+          let(:component_name)    { component.name.split("::")[1] }
+
+          let(:mock_method) { "mock_#{decamelize(msg_type)}"}
+        end
+      end
+    end
+  end
+end
+
+shared_examples "a mocking method" do |version|
+
+  context "when current_version is #{version}" do
+    before :each do
+      set_current_version(message_type, version)
+    end
+
+    after :each do
+      reset_version(message_type)
+    end
+
+    it "should return a V#{version} object if called with no argument" do
+      msg_obj = component.send(mock_method)
+      msg_obj.class.should == message_type::const_get("V#{version}")
+    end
+
+    1.upto(version) do |i|
+      it "should return a V#{i} object if called with input #{i}" do
+        msg_obj = component.send(mock_method, i)
+        msg_obj.class.should == message_type::const_get("V#{i}")
+      end
+    end
+
+    it "should raise an error if called with input > #{version}" do
+      expect {
+        msg_obj = component.send(mock_method, version + 1)
+      }.to raise_error(NameError)
+    end
+  end
+end

data/spec/support/helpers.rb

@@ -0,0 +1,54 @@
+def set_current_version(msg_type, version)
+  msg_type.stub(:current_version).and_return(version)
+  @curr_class = msg_type.current_class
+
+  @future_versions = {}
+  msg_type::constants.each do |v|
+    next if !is_message_version?(v) || !greater_version?(v, version)
+    @future_versions[v] = msg_type::const_get(v)
+    msg_type.send(:remove_const, v)
+  end
+end
+
+def reset_version(msg_type)
+  @future_versions.each do |v, klass|
+    msg_type::const_set(v, klass)
+  end
+  @future_versions
+end
+
+def is_message_version?(constant)
+  !!(constant =~ /^V[0-9]+$/)
+end
+
+def greater_version?(version, benchmark)
+  version = version[1..-1].to_i
+  version > benchmark
+end
+
+def decamelize(str)
+  words = []
+  curr_word = ""
+  0.upto(str.length - 1) do |i|
+    ch = str[i]
+    if ch =~ /[A-Z]/
+      words.push(curr_word)
+      curr_word = ""
+    end
+    curr_word += ch
+  end
+  words.push(curr_word)
+  words.map! { |x| x.downcase }
+
+  # If the first letter is capitalized, then the first word here is empty
+  words.shift if words[0] == ""
+
+  words.join('_')
+end
+
+def num_mandatory_fields(msg_obj)
+  optional = msg_obj.class.schema.optional_keys
+  mandatory = Set.new(msg_obj.class.schema.schemas.keys)
+  diff = mandatory - optional
+  return diff.size
+end

data/spec/support/message_helpers.rb

@@ -0,0 +1,138 @@
+shared_examples "a message" do
+
+  version = described_class.version
+
+  let(:component_name)    { described_class.name.split("::")[1] }
+  let(:message_type_name) { described_class.name.split("::")[2] }
+  let(:message_name)      { described_class.name.split("::")[3] }
+
+  let(:component)         { Schemata::const_get(component_name) }
+  let(:message_type)      { component::const_get(message_type_name) }
+  let(:message)           { described_class }
+
+  let(:mock_method)       { "mock_#{decamelize(message_type_name)}" }
+
+  before :each do
+    set_current_version(message_type, version)
+  end
+
+  after :each do
+    reset_version(message_type)
+  end
+
+  describe "#new" do
+    it "should create a #{described_class} object with an incomplete hash" do
+      mock_hash = component.send(mock_method, 1).contents
+      first_key = mock_hash.keys[0]
+      first_value = mock_hash[first_key]
+
+      msg_obj = message.new({first_key => first_value})
+      msg_obj.class.should == message
+      msg_obj.send(first_key).should == first_value
+    end
+
+    it "should raise an error if the hash contains incorrect types" do
+      mock_hash = component.send(mock_method, 1).contents
+      first_key = mock_hash.keys[0]
+      first_value = mock_hash[first_key]
+      if first_value.kind_of? Integer
+        bad_value = "foo"
+      else
+        bad_value = 1
+      end
+
+      expect {
+        msg_obj = message.new({first_key => bad_value})
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+
+  describe "#encode" do
+    if version == 1
+      it "should return a Schemata-encoded json string, with a V1 hash also in the raw payload" do
+        msg_obj = component.send(mock_method, 1)
+        json = msg_obj.encode
+        json_hash = Yajl::Parser.parse(json)
+
+        json_hash.should have_key "V1"
+        json_hash.should have_key "min_version"
+
+        data = Schemata::HashCopyHelpers.deep_copy(json_hash["V1"])
+
+        json_hash.delete("V1")
+        json_hash.delete("min_version")
+
+        json_hash.should == data
+      end
+    else
+      it "should return a Schemata-encoded json string, with no raw payload" do
+        msg_obj = component.send(mock_method, version)
+        json = msg_obj.encode
+        json_hash = Yajl::Parser.parse(json)
+
+        1.upto(version) do |i|
+          json_hash.should have_key "V#{i}"
+        end
+        json_hash.should have_key "min_version"
+
+        data = Schemata::HashCopyHelpers.deep_copy(json_hash["V#{version}"])
+        1.upto(version) do |i|
+          json_hash.delete("V#{i}")
+        end
+        json_hash.delete("min_version")
+
+        json_hash.should be_empty
+      end
+    end
+  end
+
+  described_class.schema.schemas.keys.each do |attr|
+    describe "##{attr}" do
+      it "should the attribute if it was specified at instantiation" do
+        mock_value = component.send(mock_method, version).contents[attr]
+        msg_obj = message.new({ attr => mock_value })
+        msg_obj.send(attr).should == mock_value
+      end
+
+      it "should return the attribute if it was set with an attr writer" do
+        mock_value = component.send(mock_method, version).contents[attr]
+        msg_obj = message.new
+        msg_obj.send("#{attr}=", mock_value)
+        msg_obj.send(attr).should == mock_value
+      end
+
+      it "should return nil if the attribute was never set" do
+        msg_obj = message.new
+        msg_obj.send(attr).should be_nil
+      end
+    end
+
+    describe "##{attr}=" do
+      it "should change the attribute and return the new value" do
+        mock_value = component.send(mock_method, version).contents[attr]
+        msg_obj = message.new({ attr => mock_value })
+        ret = (msg_obj.send("#{attr}=", mock_value))
+        msg_obj.send(attr).should == mock_value
+        ret.should == mock_value
+      end
+
+      unless described_class.schema.schemas[attr].kind_of? Membrane::Schema::Any
+        it "should raise an error if the wrong type is written" do
+          mock_value = component.send(mock_method, version).contents[attr]
+
+          if mock_value.kind_of? Integer
+            bad_value = "foo"
+          else
+            bad_value = 1
+          end
+
+          msg_obj = message.new
+
+          expect {
+            msg_obj.send("#{attr}=", bad_value)
+          }.to raise_error(Schemata::UpdateAttributeError)
+        end
+      end
+    end
+  end
+end