schemata-cloud_controller 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/component2/component2_bar_spec.rb

@@ -0,0 +1,140 @@
+require 'schemata/component2/component2'
+require 'support/helpers'
+
+describe Schemata::Component2 do
+  before :each do
+    @v10_msg = '{
+      "min_version": 10,
+      "V10": {
+        "bar1": "first",
+        "bar2": "second"
+      }
+    }'
+
+    @v11_msg = '{
+      "min_version": 10,
+      "V11": {
+        "bar1": 1,
+        "bar3": "third"
+      },
+      "V10": {
+        "bar1": "1",
+        "bar2": "second"
+      }
+    }'
+
+    @v10_hash = {
+      "bar1" => "1",
+      "bar2" => "second"
+    }
+
+    @v11_hash = {
+      "bar1" => 1,
+      "bar3" => "third"
+    }
+  end
+
+  describe "#decode" do
+    describe "(current version is 10)" do
+      before :each do
+        set_current_version(Schemata::Component2::Bar, 10)
+      end
+
+      after :each do
+        reset_version(Schemata::Component2::Bar)
+      end
+
+      it "should take a v10 msg and create a v10 obj" do
+        msg_obj = Schemata::Component2::Bar.decode(@v10_msg)
+        msg_obj.bar1.should == "first"
+        msg_obj.bar2.should == "second"
+      end
+
+      it "should take a v11 msg and create a v10 obj" do
+        msg_obj = Schemata::Component2::Bar.decode(@v11_msg)
+        msg_obj.bar1.should == "1"
+        msg_obj.bar2.should == "second"
+      end
+    end
+
+    describe "(current version is 11)" do
+      before :each do
+        set_current_version(Schemata::Component2::Bar, 11)
+      end
+
+      after :each do
+        reset_version(Schemata::Component2::Bar)
+      end
+
+      it "should take a v10 msg and create a v11 obj" do
+        msg_obj = Schemata::Component2::Bar.decode(@v10_msg)
+        msg_obj.bar1.should == 5
+        msg_obj.bar3.should == "third"
+      end
+
+      it "should take a v11 msg and create a v11 obj" do
+        msg_obj = Schemata::Component2::Bar.decode(@v11_msg)
+        msg_obj.bar1.should == 1
+        msg_obj.bar3.should == "third"
+      end
+    end
+  end
+
+  describe "#encode" do
+    describe "(current version is 10)" do
+      before :each do
+        set_current_version(Schemata::Component2::Bar, 10)
+      end
+
+      after :each do
+        reset_version(Schemata::Component2::Bar)
+      end
+
+      it "should take a v10 obj and encode a json msg" do
+        v10_obj = Schemata::Component2::Bar::V10.new(@v10_hash)
+        json_msg = v10_obj.encode
+        returned_hash = Yajl::Parser.parse(json_msg)
+
+        returned_hash.keys.should =~ ['min_version', 'V10']
+        returned_hash['min_version'].should ==
+          @curr_class::MIN_VERSION_ALLOWED
+
+        v10 = returned_hash['V10']
+        v10.each do |k, v|
+          v10[k].should == @v10_hash[k]
+        end
+      end
+    end
+
+    describe "(current version is 11)" do
+      before :each do
+        set_current_version(Schemata::Component2::Bar, 11)
+      end
+
+      it "should take a v11 obj and encode a json msg" do
+        aux_data = {"bar2" => "second" }
+        v11_obj = Schemata::Component2::Bar::V11.new(@v11_hash, aux_data)
+        json_msg = v11_obj.encode
+        returned_hash = Yajl::Parser.parse(json_msg)
+
+        returned_hash.keys.should =~ ['min_version', 'V10', 'V11']
+        returned_hash['min_version'].should ==
+          @curr_class::MIN_VERSION_ALLOWED
+
+        v10 = returned_hash['V10']
+        v10.each do |k, v|
+          v10[k].should == @v10_hash[k]
+        end
+
+        v11 = returned_hash['V11']
+        v11.each do |k, v|
+          v11[k].should == @v11_hash[k]
+        end
+      end
+
+      after :each do
+        reset_version(Schemata::Component2::Bar)
+      end
+    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/health_manager/health_manager_spec.rb

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

data/spec/health_manager/health_request_spec.rb

@@ -0,0 +1,12 @@
+require 'schemata/health_manager'
+require 'spec_helper'
+
+describe Schemata::HealthManager::HealthRequest do
+  it_behaves_like "a message type"
+end
+
+Schemata::HealthManager::HealthRequest.versions.each do |v|
+  describe Schemata::HealthManager::HealthRequest::const_get("V#{v}") do
+    it_behaves_like "a message"
+  end
+end

data/spec/health_manager/health_response_spec.rb

@@ -0,0 +1,12 @@
+require 'schemata/health_manager'
+require 'spec_helper'
+
+describe Schemata::HealthManager::HealthResponse do
+  it_behaves_like "a message type"
+end
+
+Schemata::HealthManager::HealthResponse.versions.each do |v|
+  describe Schemata::HealthManager::HealthResponse::const_get("V#{v}") do
+    it_behaves_like "a message"
+  end
+end

data/spec/health_manager/status_crashed_response_spec.rb

@@ -0,0 +1,12 @@
+require 'schemata/health_manager'
+require 'spec_helper'
+
+describe Schemata::HealthManager::StatusCrashedResponse do
+  it_behaves_like "a message type"
+end
+
+Schemata::HealthManager::StatusCrashedResponse.versions.each do |v|
+  describe Schemata::HealthManager::StatusCrashedResponse::const_get("V#{v}") do
+    it_behaves_like "a message"
+  end
+end

data/spec/health_manager/status_flapping_response_spec.rb

@@ -0,0 +1,12 @@
+require 'schemata/health_manager'
+require 'spec_helper'
+
+describe Schemata::HealthManager::StatusFlappingResponse do
+  it_behaves_like "a message type"
+end
+
+Schemata::HealthManager::StatusFlappingResponse.versions.each do |v|
+  describe Schemata::HealthManager::StatusFlappingResponse::const_get("V#{v}") do
+    it_behaves_like "a message"
+  end
+end

data/spec/health_manager/status_request_spec.rb

@@ -0,0 +1,12 @@
+require 'schemata/health_manager'
+require 'spec_helper'
+
+describe Schemata::HealthManager::StatusRequest do
+  it_behaves_like "a message type"
+end
+
+Schemata::HealthManager::StatusRequest.versions.each do |v|
+  describe Schemata::HealthManager::StatusRequest::const_get("V#{v}") do
+    it_behaves_like "a message"
+  end
+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