epc 1.0.2

data/test/command/create_group_command_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class CreateGroupCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateGroupCommand.new(@mock_client)
+    end
+
+    should "fail if no names are specified" do
+      assert_raise EPC::Error::FatalError do
+        assert_equal(@command.execute, 1)
+      end
+    end
+
+    should "fail if status is not 201" do
+      @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)
+    end
+
+    should "request the creation of the group" do
+
+      @mock_client.expects(:post).with(EPC::Config::GROUPS_PATH, {:name => "admins"}).
+        returns([201, {}, {}])
+      @command.expects(:say).with("Group [admins] created")
+
+      assert_equal(@command.execute("", "admins"), 201)
+    end
+  end
+end

data/test/command/create_library_command_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+class CreateLibraryCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateLibraryCommand.new(@mock_client)
+    end
+      
+    should "fail if arguments are not correct" do
+      assert_raise EPC::Error::FatalError do
+        assert_equal(@command.execute("", "lib1", "ruby"), 1)
+      end
+    end
+
+    should "determine the language id based on the name" do
+      @command.expects(:get_resource_id).with(EPC::Config::LIBRARY_LANGUAGES_PATH, :name, "ruby", :case_sensitivity => false).returns(1)
+      @mock_client.expects(:post).returns([201, {}, {}])
+      @command.expects(:say)
+
+      assert_equal(@command.execute("", "lib1", "ruby", "1"), 201)
+    end
+
+    should "fail if it can't determine the language id" do
+      @command.expects(:get_resource_id).with(EPC::Config::LIBRARY_LANGUAGES_PATH, :name, "ruby", :case_sensitivity => false).returns(nil)
+      assert_raise EPC::Error::InputError do
+        assert_equal(@command.execute("", "lib1", "ruby", "1"), 1)
+      end
+
+    end
+ 
+    should "fail if status is not 200" do
+      @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)
+    end
+
+    should "create a library" do
+      @mock_client.expects(:post).with(EPC::Config::LIBRARIES_PATH, {:name => "lib1", :language_id => 1, :library_version => "0.2", :group => "my_grp"}).
+        returns([201, {:id => 1}, {}])
+      @command.expects(:say).with("Created library [lib1] with ID [1]")
+
+      @command.execute("", "lib1", 1, "0.2", "my_grp")
+    end
+
+    context "library with a file to upload" do
+      should "upload the file" do
+        @mock_client.expects(:post).returns([201, {:id => 1, :url => "http://foo", :signature => "abc"}, {}])
+        @command.expects(:say).with("Created library [lib1] with ID [1]")
+        @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)
+      end
+    end
+
+  end
+end

data/test/command/create_librarylanguage_command_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class CreateLibrarylanguageCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateLibrarylanguageCommand.new(@mock_client)
+    end
+
+    should "fail if no names are specified" do
+      assert_raise EPC::Error::FatalError do
+        assert_equal(@command.execute, 1)
+      end
+    end
+
+    should "fail if status is not 201" do
+      @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)
+    end
+
+
+    should "be able to create multiple libraries" do
+      @mock_client.expects(:post).with(EPC::Config::LIBRARY_LANGUAGES_PATH, {:name => "ruby"}).
+        returns([201, {}, {}])
+      @command.expects(:say).with("Language [ruby] added")
+
+      @mock_client.expects(:post).with(EPC::Config::LIBRARY_LANGUAGES_PATH, {:name => "java"}).
+        returns([201, {}, {}])
+      @command.expects(:say).with("Language [java] added")
+
+      assert_equal(@command.execute("", "ruby", "java"), 0)
+    end
+
+
+    should "continue with creation even if one request fails" do
+      @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]")
+
+      @mock_client.expects(:post).with(EPC::Config::LIBRARY_LANGUAGES_PATH, {:name => "java"}).
+        returns([201, {}, {}])
+      @command.expects(:say).with("Language [java] added")
+
+      assert_equal(@command.execute("", "ruby", "java"), 0)
+    end
+  end
+end

data/test/command/create_libraryset_command_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+class CreateLibrarysetCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateLibrarysetCommand.new(@mock_client)
+    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(:get_resource_id).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)
+    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)
+    end
+
+    should "create the set" do
+      @mock_client.expects(:post).with(EPC::Config::LIBRARY_SETS_PATH, {:name => "rubylibs", :language_id => 1}).
+        returns([201, {}, {}])
+      @command.expects(:say).with("Set [rubylibs] created")
+
+      assert_equal(@command.execute("", "rubylibs", "1"), 201)
+    end
+
+    context "adding from file" do
+      setup do
+        @command.options[:file] = "/path/to/file"
+        @mock_client.expects(:post).with(EPC::Config::LIBRARY_SETS_PATH, {:name => "rubylibs", :language_id => 1}).
+          returns([201, {:id => 1}, {}])
+        @command.expects(:say).with("Set [rubylibs] created")
+      end
+
+      should "retrieve ids based on name/version/group" do
+        EPC::Config.expects(:read_content_as_json).with("/path/to/file").returns([{"name" => "lib1", "library_version" => "1", "group" => "grp"}])
+        @command.expects(:retrieve_libraries).with([{:name => "lib1", :library_version => "1", :group => "grp"}]).returns([1])
+        @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)
+      end
+
+      should "notify when a library fails to be attached" do
+        EPC::Config.expects(:read_content_as_json).with("/path/to/file").returns([{"name" => "lib1", "library_version" => "1", "group" => "grp"}])
+        @command.expects(:retrieve_libraries).with([{:name => "lib1", :library_version => "1", :group => "grp"}]).returns([1])
+        @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)
+      end
+    end
+  end
+end

data/test/command/create_objectrole_command_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class CreateObjectroleCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateObjectroleCommand.new(@mock_client)
+    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")
+    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")
+    end
+  end
+
+end

data/test/command/create_project_command_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+
+class CreateProjectCommandTest < Test::Unit::TestCase
+
+  should_require_login
+
+  context "execution" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateProjectCommand.new(@mock_client)
+    end
+
+    should "report error if 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)
+      end
+    end
+
+    should "fail if solution can't be infered" do
+      @command.options[:type] = 1
+      @command.expects(:infer_solution_context).returns(nil)
+      assert_raise EPC::Error::InputError do
+        assert_equal(@command.execute("", "FirstProject"), 1)
+      end
+    end
+  end
+
+  context "creation" do
+    setup do
+      @mock_client = mock("Client")
+      @mock_config = mock("Config")
+      
+      EPC::Config.target_file = '~/.epc_test_target'
+      @command = EPC::Command::CreateProjectCommand.new(@mock_client, {:solution_name => "FirstSolution"})
+      @command.options[:type] = 1
+      @command.expects(:infer_solution_context).returns([1, "FirstSolution"])
+    end
+    
+    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 }).
+        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"), 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 }).
+        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)
+    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 }).
+        returns([201, { :id => 1, :current_version_number => 99 }, {}])
+      FileUtils.expects(:mkdir).with("TestProject", {}).raises(SystemCallError.new("File exists - TestProject"))
+      
+      @command.expects(:ask_yn).returns("Y")      
+      @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)
+    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 }).
+        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)
+    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  }).
+        raises(StandardError.new("failed"))
+      
+      @command.expects(:ask_yn).returns("Y")
+      @command.expects(:say).with("Project creation failed [failed].")
+      
+      assert_equal(@command.execute("", "TestProject"), 1)
+    end
+  end
+end

data/test/command/create_role_command_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class CreateRoleCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateRoleCommand.new(@mock_client)
+    end
+
+    should "fail if no role name specified" do
+      assert_raise EPC::Error::FatalError do
+        @command.execute
+      end
+    end
+
+    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")
+    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")
+    end
+  end
+
+end

data/test/command/create_serviceversion_command_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+class CreateServiceversionCommandTest < Test::Unit::TestCase
+
+  should_require_login
+
+  context "execution" do
+
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateServiceversionCommand.new(@mock_client)
+    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}).
+        returns([404, {:message => "Not Found"}, {}])
+      @command.expects(:say).with("Request failed: [Not Found]")
+
+      assert_equal(@command.execute("", "main_db", 1), 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}).
+        returns([201, {}, {}])
+      @command.expects(:say).with("Service version successfully created.")
+      assert_equal(@command.execute("", "main_db", 1), 201)
+    end
+
+    should "allow up/down scripts" do
+      @command.options[:up_script] = "up_script.rb"
+      @command.options[:down_script] = "down_script.rb"
+
+      @command.expects(:read_file).with("up_script.rb").returns("up()")
+      @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()"}).
+        returns([201, {}, {}])
+      @command.expects(:say).with("Service version successfully created.")
+      assert_equal(@command.execute("", "main_db", 1), 201)
+    end
+
+  end
+end
+