epc 1.0.3 → 1.0.4

data/test/command/create_group_command_test.rb

@@ -19,7 +19,7 @@ class CreateGroupCommandTest < Test::Unit::TestCase
       @mock_client.expects(:post).with(EPC::Config::GROUPS_PATH, {:name => "group"}).
         returns([500, {:message => "System exception"}, {}])
       @command.expects(:say).with("Failed to create [group] group: [System exception]")
-      assert_equal(@command.execute("", "group"), 500)
+      assert_equal(@command.execute(["group"]), 500)
     end
 
     should "request the creation of the group" do
@@ -28,7 +28,7 @@ class CreateGroupCommandTest < Test::Unit::TestCase
         returns([201, {}, {}])
       @command.expects(:say).with("Group [admins] created")
 
-      assert_equal(@command.execute("", "admins"), 201)
+      assert_equal(@command.execute(["admins"]), 201)
     end
   end
 end

data/test/command/create_library_command_test.rb

@@ -11,7 +11,7 @@ class CreateLibraryCommandTest < Test::Unit::TestCase
       
     should "fail if arguments are not correct" do
       assert_raise EPC::Error::FatalError do
-        assert_equal(@command.execute("", "lib1", "ruby"), 1)
+        assert_equal(@command.execute(["lib1", "ruby"]), 1)
       end
     end
 
@@ -20,13 +20,13 @@ class CreateLibraryCommandTest < Test::Unit::TestCase
       @mock_client.expects(:post).returns([201, {}, {}])
       @command.expects(:say)
 
-      assert_equal(@command.execute("", "lib1", "ruby", "1"), 201)
+      assert_equal(@command.execute(["lib1", "ruby", "1"]), 201)
     end
 
     should "fail if it can't determine the language id" do
       @command.expects(:retrieve_identifier_for).returns(nil)
       assert_raise EPC::Error::InputError do
-        assert_equal(@command.execute("", "lib1", "ruby", "1"), 1)
+        assert_equal(@command.execute(["lib1", "ruby", "1"]), 1)
       end
 
     end
@@ -36,7 +36,7 @@ class CreateLibraryCommandTest < Test::Unit::TestCase
       @mock_client.expects(:post).returns([404, {:message => "Not Found"}, {}])
       @command.expects(:say).with("Request failed: [Not Found]")
 
-      assert_equal(@command.execute("", "lib1", 1, "0.2", "my_grp"), 404)
+      assert_equal(@command.execute(["lib1", 1, "0.2", "my_grp"]), 404)
     end
 
     should "create a library" do
@@ -45,7 +45,7 @@ class CreateLibraryCommandTest < Test::Unit::TestCase
         returns([201, {:id => 1}, {}])
       @command.expects(:say).with("Created library [lib1] with ID [1]")
 
-      @command.execute("", "lib1", 1, "0.2", "my_grp")
+      @command.execute(["lib1", 1, "0.2", "my_grp"])
     end
 
     context "library with a file to upload" do
@@ -56,7 +56,7 @@ class CreateLibraryCommandTest < Test::Unit::TestCase
         @command.expects(:sha1).with("/a/file")
         @command.expects(:upload_library).with("/a/file", "http://foo", "abc")
         @command.options[:file] ="/a/file"
-        assert_equal(@command.execute("", "lib1", 1, "0.2", "my_grp"), 201)
+        assert_equal(@command.execute(["lib1", 1, "0.2", "my_grp"]), 201)
       end
     end
 

data/test/command/create_librarylanguage_command_test.rb

@@ -19,7 +19,7 @@ class CreateLibrarylanguageCommandTest < Test::Unit::TestCase
       @mock_client.expects(:post).with(EPC::Config::LIBRARY_LANGUAGES_PATH, {:name => "ruby"}).
         returns([500, {:message => "System exception"}, {}])
       @command.expects(:say).with("Failed to create [ruby] language: [System exception]")
-      assert_equal(@command.execute("", "ruby"), 1)
+      assert_equal(@command.execute(["ruby"]), 1)
     end
 
 
@@ -32,7 +32,7 @@ class CreateLibrarylanguageCommandTest < Test::Unit::TestCase
         returns([201, {}, {}])
       @command.expects(:say).with("Language [java] added")
 
-      assert_equal(@command.execute("", "ruby", "java"), 0)
+      assert_equal(@command.execute(["ruby", "java"]), 0)
     end
 
 
@@ -45,7 +45,7 @@ class CreateLibrarylanguageCommandTest < Test::Unit::TestCase
         returns([201, {}, {}])
       @command.expects(:say).with("Language [java] added")
 
-      assert_equal(@command.execute("", "ruby", "java"), 0)
+      assert_equal(@command.execute(["ruby", "java"]), 0)
     end
   end
 end

data/test/command/create_libraryset_command_test.rb

@@ -7,40 +7,20 @@ class CreateLibrarysetCommandTest < Test::Unit::TestCase
     setup do
       @mock_client = mock("Client")
       @command = EPC::Command::CreateLibrarysetCommand.new(@mock_client)
+      @command.expects(:retrieve_identifier_for).returns(1)
     end
 
-
-    should "fail if no name is specified" do
-      assert_raise EPC::Error::FatalError do
-        assert_equal(@command.execute(""), 1)
-      end
-    end
-
-    should "fail if no language is specified" do
-      assert_raise EPC::Error::FatalError do
-        @command.execute("", "set")
-      end
-    end
-
-
     should "create the set with a language associated if one specified" do
       @mock_client.expects(:post).with(EPC::Config::LIBRARY_SETS_PATH, {:name => "rubylibs", :language_id => 1}).returns([201, {}, {}])
       @command.expects(:say)
-      assert_equal(@command.execute("", "rubylibs", "1"), 201)
-    end
-
-    should "retrieve the language id" do
-      @command.expects(:retrieve_identifier_for).returns(1)
-      @mock_client.expects(:post).with(EPC::Config::LIBRARY_SETS_PATH, {:name => "rubylibs", :language_id => 1}).returns([201, {}, {}])
-      @command.expects(:say)
-      assert_equal(@command.execute("", "rubylibs", "ruby"), 201)
+      assert_equal(@command.execute(["rubylibs", "1"]), 201)
     end
 
     should "fail if status is not 201" do
       @mock_client.expects(:post).with(EPC::Config::LIBRARY_SETS_PATH, {:name => "rubylibs", :language_id => 1}).
         returns([500, {:message => "System exception"}, {}])
       @command.expects(:say).with("Request failed: [System exception]")
-      assert_equal(@command.execute("", "rubylibs", "1"), 500)
+      assert_equal(@command.execute(["rubylibs", "1"]), 500)
     end
 
     should "create the set" do
@@ -48,7 +28,7 @@ class CreateLibrarysetCommandTest < Test::Unit::TestCase
         returns([201, {}, {}])
       @command.expects(:say).with("Set [rubylibs] created")
 
-      assert_equal(@command.execute("", "rubylibs", "1"), 201)
+      assert_equal(@command.execute(["rubylibs", "1"]), 201)
     end
 
     context "adding from file" do
@@ -65,7 +45,7 @@ class CreateLibrarysetCommandTest < Test::Unit::TestCase
         @mock_client.expects(:post).with(EPC::Config::LIBRARY_SETS_PATH + "/1/attach_library", :library_id => 1).returns([200, {}, {}])
         @command.expects(:say).with("Library [1] added to set")
 
-        assert_equal(@command.execute("", "rubylibs", "1"), 0)
+        assert_equal(@command.execute(["rubylibs", "1"]), 0)
       end
 
       should "notify when a library fails to be attached" do
@@ -74,7 +54,7 @@ class CreateLibrarysetCommandTest < Test::Unit::TestCase
         @mock_client.expects(:post).with(EPC::Config::LIBRARY_SETS_PATH + "/1/attach_library", :library_id => 1).returns([404, {:message => "Not Found"}, {}])
         @command.expects(:say).with("Failed to add [1]: [Not Found]")
 
-        assert_equal(@command.execute("", "rubylibs", "1"), 1)
+        assert_equal(@command.execute(["rubylibs", "1"]), 1)
       end
     end
   end

data/test/command/create_objectrole_command_test.rb

@@ -7,30 +7,21 @@ class CreateObjectroleCommandTest < Test::Unit::TestCase
     setup do
       @mock_client = mock("Client")
       @command = EPC::Command::CreateObjectroleCommand.new(@mock_client)
+      @command.target_id = "1"
+      @command.target_type = "Solution"
     end
 
-    should "fail if no role name and object specified" do
-      assert_raise EPC::Error::FatalError do
-        @command.execute
-      end
-    end
-
-    should "fail if object is not specified correctly" do
-      assert_raise EPC::Error::FatalError do
-        @command.execute("Solution", "admin")
-      end
-    end
 
     should "request creation of the role" do
       @mock_client.expects(:post).with(EPC::Config::ROLES_PATH, {:name => "Admin", :owner_id => "1", :owner_type => "Solution"}).returns([200, {}, {}])
       @command.expects(:say).with("Role [Admin] created")
-      @command.execute("Solution:1", "Admin")
+      @command.execute(["Admin"])
     end
 
     should "report reason for request failure" do
       @mock_client.expects(:post).with(EPC::Config::ROLES_PATH, {:name => "Admin", :owner_id => "1", :owner_type => "Solution"}).returns([500, {:message => "System Exception"}, {}])
       @command.expects(:say).with("Request failed: [System Exception]")
-      @command.execute("Solution:1", "Admin")
+      @command.execute(["Admin"])
     end
   end
 

data/test/command/create_project_command_test.rb

@@ -10,11 +10,11 @@ class CreateProjectCommandTest < Test::Unit::TestCase
       @command = EPC::Command::CreateProjectCommand.new(@mock_client)
     end
 
-    should "report error if project_name is nil" do
+    should "report error if the project name is nil" do
       @command.expects(:infer_solution_context).never
       @mock_client.expects(:post).never
       assert_raise EPC::Error::FatalError do 
-        @command.execute(nil)
+        @command.execute
       end
     end
 
@@ -22,7 +22,7 @@ class CreateProjectCommandTest < Test::Unit::TestCase
       @command.options[:type] = 1
       @command.expects(:infer_solution_context).returns(nil)
       assert_raise EPC::Error::InputError do
-        assert_equal(@command.execute("", "FirstProject"), 1)
+        assert_equal(@command.execute(["FirstProject"]), 1)
       end
     end
   end
@@ -41,7 +41,7 @@ class CreateProjectCommandTest < Test::Unit::TestCase
     should "create the project directory if the status is 201" do
       @command.options[:type] = "Ruby"
       @command.expects(:get_resource_id).with(EPC::Config::PROJECT_TYPES_PATH, :name, "Ruby", :case_sensitivity => false).returns(1)
-      @mock_client.expects(:post).with("/api/v1/projects", { :project_name => 'FirstProject', :solution_name => "FirstSolution", :uri_name => "FirstProject", :project_type_id => 1 }).
+      @mock_client.expects(:post).with("/api/v1/projects", { :name => 'FirstProject', :solution_name => "FirstSolution", :uri_name => "FirstProject", :project_type_id => 1, :runtime_memory => nil }).
         returns([201, { :id => 1, :current_version_number => 99 }, {}])
       EPC::Config.expects(:write_project_metadata).with(1, @mock_client)
    
@@ -49,24 +49,24 @@ class CreateProjectCommandTest < Test::Unit::TestCase
       @command.expects(:mkdir).with("FirstProject").returns(:ok)
       @command.expects(:say).with("Successfully created the project with [http://localhost:3000] and created your local directory.")
       
-      assert_equal(@command.execute("", "FirstProject"), 201)
+      assert_equal(@command.execute(["FirstProject"]), 201)
     end
 
     should "skip directory creation if --nodir option was passed" do
       @command.instance_variable_get(:@options)[:nodir] = true
 
-      @mock_client.expects(:post).with("/api/v1/projects", { :project_name => 'FirstProject', :solution_name => "FirstSolution", :uri_name => "FirstProject", :project_type_id => 1 }).
+      @mock_client.expects(:post).with("/api/v1/projects", { :name => 'FirstProject', :solution_name => "FirstSolution", :uri_name => "FirstProject", :project_type_id => 1, :runtime_memory => nil }).
         returns([201, { :id => 1, :current_version_number => 99 }, {}])
 
       @command.expects(:ask_yn).returns("Y")
       @command.expects(:say).with("Successfully created the project with [http://localhost:3000]")
       
-      assert_equal(@command.execute("", "FirstProject"), 201)
+      assert_equal(@command.execute(["FirstProject"]), 201)
     end
 
     should "report failure if the status is 201 and the solution directory cannot be created" do
     
-      @mock_client.expects(:post).with("/api/v1/projects", { :project_name => 'TestProject', :solution_name => "FirstSolution", :uri_name => "TestProject", :project_type_id => 1 }).
+      @mock_client.expects(:post).with("/api/v1/projects", { :name => 'TestProject', :solution_name => "FirstSolution", :uri_name => "TestProject", :project_type_id => 1, :runtime_memory => nil }).
         returns([201, { :id => 1, :current_version_number => 99 }, {}])
       FileUtils.expects(:mkdir).with("TestProject", {}).raises(SystemCallError.new("File exists - TestProject"))
       
@@ -74,29 +74,43 @@ class CreateProjectCommandTest < Test::Unit::TestCase
       @command.expects(:say).with("Failed to create local directory [TestProject] - [unknown error - File exists - TestProject]")
       @command.expects(:say).with("Successfully created the project with [http://localhost:3000], but FAILED to create your local directory.")
       
-      assert_equal(@command.execute("", "TestProject"), 201)
+      assert_equal(@command.execute(["TestProject"]), 201)
+    end
+
+    should "send the runtime memory when supplied"  do
+      @command.options[:type] = "Ruby"
+      @command.expects(:get_resource_id).with(EPC::Config::PROJECT_TYPES_PATH, :name, "Ruby", :case_sensitivity => false).returns(1)
+      @mock_client.expects(:post).with("/api/v1/projects", { :name => 'FirstProject', :solution_name => "FirstSolution", :uri_name => "FirstProject", :project_type_id => 1, :runtime_memory => 128 }).
+        returns([201, { :id => 1, :current_version_number => 99 }, {}])
+      EPC::Config.expects(:write_project_metadata).with(1, @mock_client)
+
+      @command.expects(:ask_yn).returns("Y")
+      @command.expects(:mkdir).with("FirstProject").returns(:ok)
+      @command.expects(:say).with("Successfully created the project with [http://localhost:3000] and created your local directory.")
+
+      assert_equal(@command.execute(["FirstProject",nil,128]), 201)
     end
     
     should "report failure if the status is not 201" do
     
-      @mock_client.expects(:post).with("/api/v1/projects", { :project_name => 'TestProject', :solution_name => "FirstSolution", :uri_name => "TestProject", :project_type_id => 1 }).
+      @mock_client.expects(:post).with("/api/v1/projects", { :name => 'TestProject', :solution_name => "FirstSolution", :uri_name => "TestProject", :project_type_id => 1, :runtime_memory => nil }).
         returns([400, { :message => "Bad Request" }, {}])
         
       @command.expects(:ask_yn).returns("Y")
       @command.expects(:say).with("Project creation failed [Bad Request].")
       
-      assert_equal(@command.execute("", "TestProject"), 400)
+      assert_equal(@command.execute(["TestProject"]), 400)
     end
     
     should "report error if the call throws an exception" do
       
-      @mock_client.expects(:post).with("/api/v1/projects", { :project_name => 'TestProject', :solution_name => "FirstSolution", :uri_name => "TestProject", :project_type_id => 1  }).
+      @mock_client.expects(:post).with("/api/v1/projects", { :name => 'TestProject', :solution_name => "FirstSolution", :uri_name => "TestProject", :project_type_id => 1, :runtime_memory => nil  }).
         raises(StandardError.new("failed"))
       
       @command.expects(:ask_yn).returns("Y")
       @command.expects(:say).with("Project creation failed [failed].")
       
-      assert_equal(@command.execute("", "TestProject"), 1)
+      assert_equal(@command.execute(["TestProject"]), 1)
     end
   end
 end

data/test/command/create_role_command_test.rb

@@ -6,6 +6,7 @@ class CreateRoleCommandTest < Test::Unit::TestCase
   context "execute" do
     setup do
       @mock_client = mock("Client")
+      EPC::Command::CreateRoleCommand.send :include, EPC::Command::Role
       @command = EPC::Command::CreateRoleCommand.new(@mock_client)
     end
 
@@ -18,13 +19,13 @@ class CreateRoleCommandTest < Test::Unit::TestCase
     should "request creation of the role" do
       @mock_client.expects(:post).with(EPC::Config::ROLES_PATH, {:name => "Admin"}).returns([200, {}, {}])
       @command.expects(:say).with("Role [Admin] created")
-      @command.execute("", "Admin")
+      @command.execute(["Admin"])
     end
 
     should "report reason for request failure" do
       @mock_client.expects(:post).with(EPC::Config::ROLES_PATH, {:name => "Admin"}).returns([500, {:message => "System Exception"}, {}])
       @command.expects(:say).with("Request failed: [System Exception]")
-      @command.execute("", "Admin")
+      @command.execute(["Admin"])
     end
   end
 

data/test/command/create_runtime_command_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class CreateRuntimeCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateRuntimeCommand.new(@mock_client)
+      @command.target_id = 1
+      @command.target_type = "RuntimeType"
+    end
+
+    should "fail if mandatory attributes not specified" do
+      assert_raise EPC::Error::FatalError do
+        @command.execute
+      end
+    end
+
+    should "request creation of the runtime" do
+      @command.expects(:retrieve_identifier_for).returns(1)
+      @mock_client.expects(:post).with(EPC::Config::RUNTIMES_PATH, {:name => "runtime", :target => "runtime_target", :runtime_env_type_id => 1, :deployment_stage_id => 1, :username => "user", :password => "pass"}).returns([200, {}, {}])
+      @command.expects(:say).with("Runtime [runtime] created")
+      @command.execute(["runtime", "runtime_target", "Development", "user", "pass" ])
+    end
+
+    should "report reason for request failure" do
+      @command.expects(:retrieve_identifier_for).returns(1)
+      @mock_client.expects(:post).with(EPC::Config::RUNTIMES_PATH, {:name => "runtime", :target => "runtime_target", :runtime_env_type_id => 1, :deployment_stage_id => 1, :username => "user", :password => "pass"}).returns([500, {:message => "System Exception"}, {}])
+      @command.expects(:say).with("Request failed: [System Exception]")
+      @command.execute(["runtime", "runtime_target", "Development", "user", "pass" ])
+    end
+
+  end
+
+
+end

data/test/command/create_servicedefinition_command_test.rb

@@ -6,37 +6,24 @@ require 'mocha'
 class CreateServicedefinitionCommandTest < Test::Unit::TestCase
   should_require_login
 
-  context "execution" do
-    setup do
-      @mock_client = mock('Client')
-    end
-
-    should "require both the name and service type" do
-      @command = EPC::Command::CreateServicedefinitionCommand.new(@mock_client)
-      assert_raise EPC::Error::FatalError do
-        @command.execute("")
-      end
-    end
-
-  end
-
   context "service definition" do
     setup do
       @mock_client = stub('Client')
       @command = EPC::Command::CreateServicedefinitionCommand.new(@mock_client, {:service_type => "MySQL"})
-      @command.expects(:retrieve_identifier_for).returns(1)
+      @command.target_id = 1
+      @command.target_type = "ServiceVersion"
     end
 
     should "fail if status is not 201" do
       @mock_client.expects(:post).with(EPC::Config::SERVICE_DEFINITIONS_PATH, {:name => "service", :type_id => 1}).returns([400, {:message => 'Not Found'}])
       @command.expects(:say).with("Service definition failed with: [Not Found]")
-      @command.execute("", "service", "MySQL") 
+      @command.execute(["service", "MySQL"]) 
     end
 
     should "define a service" do
       @mock_client.expects(:post).with(EPC::Config::SERVICE_DEFINITIONS_PATH, {:name => "service", :type_id => 1}).returns([201, {'id' => 1}])
       @command.expects(:say).with("service has been defined.")
-      @command.execute("", "service", "MySQL") 
+      @command.execute(["service", "MySQL"]) 
     end
   end
 end

data/test/command/create_serviceversion_command_test.rb

@@ -9,36 +9,23 @@ class CreateServiceversionCommandTest < Test::Unit::TestCase
     setup do
       @mock_client = mock("Client")
       @command = EPC::Command::CreateServiceversionCommand.new(@mock_client)
+      @command.target_id = 1
+      @command.target_type = "ServiceDefinition"
     end
 
-    should "require the user to input label and service definition" do
-    
-      assert_raise EPC::Error::FatalError do
-        assert_equal(@command.execute(""), 1)
-      end
-    end
-
-    should "query for the definition id and notify the user if it wasn't found" do
-      @command.expects(:get_resource_id).returns(nil)
-      assert_raise EPC::Error::InputError do
-        assert_equal(@command.execute("", "main_db", "mysql"), 1)
-      end
-    end
-
-
     should "show a message if status is not 201" do
-      @mock_client.expects(:post).with(EPC::Config::SERVICE_VERSIONS_PATH, {:label => "main_db", :definition_id => 1, :up_script => nil, :down_script => nil}).
+      @mock_client.expects(:post).with(EPC::Config::SERVICE_VERSIONS_PATH, {:label => "main_db", :service_definition_id => 1, :up_script => nil, :down_script => nil, :backwards_compatible => "false", :reversible => "false"}).
         returns([404, {:message => "Not Found"}, {}])
       @command.expects(:say).with("Request failed: [Not Found]")
 
-      assert_equal(@command.execute("", "main_db", 1), 404)
+      assert_equal(@command.execute(["main_db"]), 404)
     end
 
     should "create a service version with core" do
-      @mock_client.expects(:post).with(EPC::Config::SERVICE_VERSIONS_PATH, {:label => "main_db", :definition_id => 1, :up_script => nil, :down_script => nil}).
+      @mock_client.expects(:post).with(EPC::Config::SERVICE_VERSIONS_PATH, {:label => "main_db", :service_definition_id => 1, :up_script => nil, :down_script => nil, :backwards_compatible => "false", :reversible => "false"}).
         returns([201, {}, {}])
       @command.expects(:say).with("Service version successfully created.")
-      assert_equal(@command.execute("", "main_db", 1), 201)
+      assert_equal(@command.execute(["main_db"]), 201)
     end
 
     should "allow up/down scripts" do
@@ -49,12 +36,11 @@ class CreateServiceversionCommandTest < Test::Unit::TestCase
       @command.expects(:read_file).with("down_script.rb").returns("down()")
 
 
-      @mock_client.expects(:post).with(EPC::Config::SERVICE_VERSIONS_PATH, {:label => "main_db", :definition_id => 1, :up_script => "up()", :down_script => "down()"}).
+      @mock_client.expects(:post).with(EPC::Config::SERVICE_VERSIONS_PATH, {:label => "main_db", :service_definition_id => 1, :up_script => "up()", :down_script => "down()", :backwards_compatible => 'false', :reversible => "false"}).
         returns([201, {}, {}])
       @command.expects(:say).with("Service version successfully created.")
-      assert_equal(@command.execute("", "main_db", 1), 201)
+      assert_equal(@command.execute(["main_db"]), 201)
     end
 
   end
 end
-