epc 1.0.2

data/test/command/bind_service_command_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+class BindServiceCommandTest < Test::Unit::TestCase
+
+  should_require_login
+
+  context "binding" do  
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::BindServiceCommand.new(@mock_client)
+    end
+
+    should "fail if service version not specified" do
+      assert_raise EPC::Error::FatalError do
+        assert_equal(@command.execute, 1)
+      end
+    end
+
+    should "fail if service version id or project id cannot be determined" do
+      @command.expects(:infer_project_context).returns([nil, nil])
+      @command.expects(:get_resource_id).with(EPC::Config::SERVICE_VERSIONS_PATH, :label, "main_db").returns(nil)
+
+      assert_raise EPC::Error::FatalError do
+        assert_equal(@command.execute("main_db"), 1)
+      end
+    end
+
+    should "fail if status is not 201" do
+      @command.expects(:infer_project_context).returns([1, "FirstProject"])
+      @mock_client.expects(:post).with(EPC::Config::PROJECTS_PATH + "/1/add_service_version", {:version_id => 1}).
+        returns([404, {:message => "Not Found"}, {}])
+      @command.expects(:say).with("Request failed: [Not Found]")
+
+      assert_equal(@command.execute(1), 404)
+    end
+
+    should "bind the service to the project" do
+      @command.expects(:infer_project_context).returns([1, "FirstProject"])
+      @mock_client.expects(:post).with(EPC::Config::PROJECTS_PATH + "/1/add_service_version", {:version_id => 1}).
+        returns([201, {}, {}])
+      @command.expects(:say).with("Service bound.")
+
+      assert_equal(@command.execute(1), 201)
+    end
+  end
+end

data/test/command/build_command_test.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+class BuildCommandTest < Test::Unit::TestCase
+
+  should_require_login
+
+  context "execution" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::BuildCommand.new(@mock_client)
+    end
+
+    context "from solution directory" do
+      setup do
+        @command.expects(:infer_solution_context).returns([1, "FirstSolution"])
+        EPC::Config.expects(:is_solution_dir?).returns(true)
+      end
+
+      should "build all projects when no arguments specified" do
+        @command.expects(:ask_yn).returns("Y")
+        Dir.expects(:glob).returns(["p1_dir", "p2_dir"])
+        EPC::Config.expects(:is_project_dir?).with("p1_dir").returns(true)
+        EPC::Config.expects(:get_project_value).with("p1_dir", "id").returns(1)
+        EPC::Config.expects(:is_project_dir?).with("p2_dir").returns(true)
+        EPC::Config.expects(:get_project_value).with("p2_dir", "id").returns(2)
+        @command.expects(:create_build).returns([true, 1])
+        @command.expects(:say)
+        @command.expects(:poll_for_build_status).returns(0)
+        @command.execute 
+      end
+
+      should "only build the projects whose ids specified as arguments" do
+        @command.expects(:ask_yn).returns(1)
+        @command.execute("1=11", "2=12") 
+      end
+
+      should "only build the projects whose names specified as arguments" do
+        @command.expects(:infer_project_context).with("p1", File.expand_path("."), 1).returns([1, "p1"])
+        @command.expects(:infer_project_context).with("p2", File.expand_path("."), 1).returns([2, "p2"])
+        @command.expects(:ask_yn).returns(1)
+        @command.execute("p1=11", "p2=12") 
+      end
+    end
+
+    context "from a project directory" do
+      setup do
+        @command.expects(:infer_solution_context).returns([1, "FirstSolution"])
+        EPC::Config.expects(:is_solution_dir?).returns(false)
+        EPC::Config.expects(:is_project_dir?).returns(true)
+      end
+
+      should "build the project from the directory" do
+        @command.expects(:infer_project_context).returns([1, "FirstProject"])
+        @command.expects(:ask_yn)
+        @command.execute
+      end
+
+    end
+
+  end
+  
+  context "create_build" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::BuildCommand.new(@mock_client)
+      EPC::Config.target_file = '~/.epc_test_target'
+    end
+    
+    should "return true, id, built and message if the status is 201" do
+      @mock_client.expects(:post).with("/api/v1/builds", { :project_ids => [7], :project_versions => [], :note => nil }).
+        returns([201, { :id => 1 }, {}])
+      @command.expects(:say).with("Successfully kicked off a build with [http://localhost:3000]")
+
+      created, id = @command.send(:create_build, { 7 => 4 })
+      
+      assert(created)
+      assert_equal(1, id)
+    end
+    
+    should "return false if the status is not 200" do
+      @mock_client.expects(:post).with("/api/v1/builds", { :project_ids => [7], :project_versions => [], :note => nil }).
+        returns([404, { :message => "Not Found" }, {}])
+      @command.expects(:say).with("Build kickoff failed [Not Found]. Aborting.")
+      
+      created, id, built, message = @command.send(:create_build, { 7 => nil })
+      
+      assert(!created)
+    end
+
+    should "notify when a build in progress is found" do
+      @mock_client.expects(:post).with("/api/v1/builds", { :project_ids => [7], :project_versions => [], :note => nil }).
+        returns([202, { :id => 1}, {}])
+      @command.expects(:say).with("Build already in progress. Retrieving build status")
+
+      created, id = @command.send(:create_build, {7 => nil})
+      assert(created)
+      assert_equal(1, id)
+
+    end
+  end
+  
+
+end

data/test/command/copy_deployment_command_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class CopyDeploymentCommandTest < Test::Unit::TestCase
+
+  should_require_login
+
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CopyDeploymentCommand.new(@mock_client)
+    end
+
+    should "fail if no deployment id 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::DEPLOYMENTS_PATH + "/1/copy", :stage_name => "development").
+        returns([404, {:message => "Not Found"}, {}])
+
+      @command.expects(:say).with("Request failed: [Not Found]")
+      assert_equal(@command.execute(1, "development"), 404)
+    end
+
+    should "report the succesfull creation of new deployment" do
+      @mock_client.expects(:post).with(EPC::Config::DEPLOYMENTS_PATH + "/1/copy", :stage_name => "development").
+        returns([201, {:id => 2}, {}])
+
+      @command.expects(:say).with("Copied new deployment to the development stage. ID: 2")
+      assert_equal(@command.execute(1, "development"), 201)
+
+    end
+
+  end
+    
+end

data/test/command/create_config_command_test.rb

@@ -0,0 +1,124 @@
+require 'test_helper'
+
+class CreateConfigCommandTest < Test::Unit::TestCase
+  
+  should_require_login
+
+  context "adding" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateConfigCommand.new(@mock_client)
+    
+    end
+
+    should "fail if no key specified" do
+      assert_raise EPC::Error::FatalError do
+        @command.execute("")
+      end
+    end
+
+
+    should "fail if status code is not 201" do
+      EPC::Config.expects(:is_project_dir?).returns(true)
+
+      EPC::Config.expects(:get_project_value).returns(1)
+
+      @mock_client.expects(:post).with(EPC::Config::CONFIGURATIONS_PATH, 
+                                       {:config_values => [{:name => "key1", :value => "value1", :value_type => "text", :configurable_id => 1, :configurable_type => "Project", :required => false, :no_override => nil}]}
+      ).returns([400, {:message => "Not Found"}, {}])
+
+      @command.expects("say").with("Request failed with message [Not Found]")
+      assert_equal(@command.execute("", "key1=value1"), 400)
+       
+    end
+
+
+    should "add to specified configuration level when option is specified" do
+      command = EPC::Command::CreateConfigCommand.new(@mock_client, {:user => 2})
+
+      command.expects(:extract_configuration_level).returns(["User", 2])
+
+      @mock_client.expects(:post).with(EPC::Config::CONFIGURATIONS_PATH,
+        {:config_values => [{:name => "key1", :value => "value1", :value_type => "text", :configurable_id => 2, :configurable_type => "User", :required => false, :no_override => nil}]}
+      ).returns([201, {:id => 1}, {}])
+
+      command.expects(:say).with("Configuration values saved.")
+      assert_equal(command.execute("", "key1=value1"), 201)
+
+    end
+
+    should "add keys" do
+      @command.expects(:extract_configuration_level).returns(["Project", 1])
+
+      @mock_client.expects(:post).with(EPC::Config::CONFIGURATIONS_PATH,
+                                       {:config_values => [{:name => "key1", :value => "value1", :value_type => "text", :configurable_id => 1, :configurable_type => "Project", :required => false, :no_override => nil}]}
+      ).returns([201, {:id => 1}, {}])
+
+      @command.expects(:say).with("Configuration values saved.")
+      assert_equal(@command.execute("", "key1=value1"), 201)
+    end
+
+    should "add required key when --required flag is supplied" do
+      command = EPC::Command::CreateConfigCommand.new(@mock_client, {:required => true})
+
+      command.expects(:extract_configuration_level).returns(["Project", 1])
+
+      @mock_client.expects(:post).with(EPC::Config::CONFIGURATIONS_PATH,
+                                       {:config_values => [{:name => "key1", :value => "value1", :value_type => "text", :configurable_id => 1, :configurable_type => "Project", :required => true, :no_override => nil}]}
+      ).returns([201, {:id => 1}, {}])
+
+      command.expects(:say).with("Configuration values saved.")
+      assert_equal(command.execute("", "key1=value1"), 201)
+    end
+
+    should "should accept value-type parameter" do
+      command = EPC::Command::CreateConfigCommand.new(@mock_client, {:value_type => "URL"})
+
+      command.expects(:extract_configuration_level).returns(["Project", 1])
+
+      @mock_client.expects(:post).with(EPC::Config::CONFIGURATIONS_PATH,
+                                       {:config_values => [{:name => "key1", :value => "value1", :value_type => "URL", :configurable_id => 1, :configurable_type => "Project", :required => false, :no_override => nil}]}
+      ).returns([201, {:id => 1}, {}])
+
+      command.expects(:say).with("Configuration values saved.")
+      assert_equal(command.execute("", "key1=value1"), 201)
+    end
+
+    should "should add the stage name parameter" do
+      command = EPC::Command::CreateConfigCommand.new(@mock_client, {:value_type => "URL", :stage => "Development"})
+
+      command.expects(:extract_configuration_level).returns(["Project", 1])
+
+      @mock_client.expects(:post).with(EPC::Config::CONFIGURATIONS_PATH,
+                                       {:config_values => [{:name => "key1", :value => "value1", :value_type => "URL", :configurable_id => 1, :configurable_type => "Project", :required => false, :no_override => nil, :stage_name => "Development"}]}
+      ).returns([201, {:id => 1}, {}])
+
+      command.expects(:say).with("Configuration values saved.")
+      assert_equal(command.execute("", "key1=value1"), 201)
+    end
+
+    should "read data from external file when prompted to" do
+      @command.options[:file] = "path_to_file"
+      @command.expects(:extract_configuration_level).returns(["Project", 1])
+      EPC::Config.expects(:read_content_as_json).returns([{:name => "key1", :value => "value1", :value_type => "text", :required => true, :no_override => nil}])
+      @mock_client.expects(:post).with(EPC::Config::CONFIGURATIONS_PATH,
+                                       {:config_values => [{:name => "key1", :value => "value1", :value_type => "text", :configurable_id => 1, :configurable_type => "Project", :required => true, :no_override => nil}]}
+      ).returns([201, {:id => 1}, {}])
+
+      @command.expects(:say).with("Configuration values saved.")
+      assert_equal(@command.execute("", "key1=value1"), 201)
+    end
+
+    should "fail if no config values were supplied" do
+      assert_raise EPC::Error::FatalError do
+        @command.options[:file] = "path_to_file"
+        EPC::Config.expects(:read_content_as_json).returns([])
+        @command.expects(:extract_configuration_level).returns(["Project", 1])
+        @command.execute("")
+      end
+      
+    end
+
+  end
+
+end

data/test/command/create_dependency_command_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class CreateDependencyCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "execute" do
+
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateDependencyCommand.new(@mock_client)
+    end
+
+    should "fail if project id can't be determined (no solution)" do
+      @command.expects(:infer_solution_context).returns([ nil, nil ]) 
+      @command.expects(:infer_project_context).returns([ nil, nil ]) 
+      @command.expects(:say).with("Project/solution could not be inferred")
+      @command.expects(:say).with(EPC::Help::COMMAND_USAGES[:create_dependency])
+      assert_equal(@command.execute, 1)
+    end
+
+    should "fail if project id can't be determined" do
+      @command.expects(:infer_solution_context).returns([ 1, "FirstSolution" ]) 
+      @command.expects(:infer_project_context).returns([ 1, "FirstProject" ]) 
+      @command.expects(:get_resource_id).returns(nil)
+      @command.expects(:say).with("Dependency could not be inferred")
+      @command.expects(:say).with(EPC::Help::COMMAND_USAGES[:create_dependency])
+      assert_equal(@command.execute, 1)
+    end
+
+    should "show a message if status is not 201" do
+      @command.options[:dependency] = "dependency_name"
+      @command.expects(:infer_project_context).returns([1, "FirstProject"])
+      @command.expects(:infer_solution_context).returns([1, "FirstSolution"])
+      @command.expects(:get_resource_id).returns(2)
+      @mock_client.expects(:post).with(EPC::Config::PROJECTS_PATH + "/1/add_dependency", {:dependency_id => 2, :dependency_kind => 1}).
+        returns([400, {:message => "Not Found"}, {}])
+      @command.expects(:say).with("Request failed: [Not Found]")
+
+      assert_equal(@command.execute, 400)
+    end
+
+    should "do a POST request to core" do
+      @command.options[:dependency_type] = 2
+      @command.options[:dependency] = 2
+      @command.expects(:infer_project_context).returns([1, "FirstProject"])
+      @command.expects(:infer_solution_context).returns([1, "FirstSolution"])
+
+      @mock_client.expects(:post).with(EPC::Config::PROJECTS_PATH + "/1/add_dependency", {:dependency_id => 2, :dependency_kind => 2}).returns([201, {}, {}])
+      @command.expects(:say).with("Dependency defined")
+
+      assert_equal(@command.execute, 201)
+    end
+    
+  end
+end

data/test/command/create_deployment_command_test.rb

@@ -0,0 +1,136 @@
+require 'test_helper'
+
+class CreateDeploymentCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "pre-execution checks" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateDeploymentCommand.new(@mock_client, {:solution_name => "FirstSolution"})
+    end
+
+    should "fail if solution can't be inferred " do
+      assert_raise EPC::Error::FatalError do
+        @command.expects(:infer_solution_context).returns(nil)
+        assert_equal @command.execute, 1
+      end
+    end
+  end
+
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @mock_config = mock("Config")
+      
+      EPC::Config.solutions_projects_file = '~/.epc_test_solutions_projects'
+      @command = EPC::Command::CreateDeploymentCommand.new(@mock_client, {:solution_name => "FirstSolution"})
+      @command.expects(:infer_solution_context).returns([1, "FirstSolution"])
+    end
+    
+    teardown do
+      file = File.expand_path(EPC::Config.solutions_projects_file)
+      FileUtils.rm(file) if File.exists?(file)
+    end
+    
+    
+    should "report failure if the status is not 201" do
+      @mock_client.expects(:post).with("/api/v1/deployments",
+        { :solution_name => "FirstSolution", :stage_name => "Development" }).  
+        returns([404, { :message => "Not Found" }, {}])
+        
+      
+      @command.expects(:ask_yn).returns("Y")
+      @command.expects(:say).with("Deployment creation failed [Not Found]. Aborting.")
+      
+      assert_equal(@command.execute("", "Development"), 404)
+    end
+    
+    should "report failure if it catches an exception" do
+      @mock_client.expects(:post).with("/api/v1/deployments",
+        { :solution_name => "FirstSolution", :stage_name => "Development" }).
+        raises(StandardError.new("failed"))
+        
+      @command.expects(:ask_yn).returns("Y")
+      @command.expects(:say).with("Create deployment failed [Exception Caught (StandardError): failed].")
+      
+      assert_equal(@command.execute("", "Development"), 1)
+    end
+  end
+
+  context "deployment replacement" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateDeploymentCommand.new(@mock_client, {:solution_name => "FirstSolution"})
+      @command.expects(:infer_solution_context).returns([1, "FirstSolution"])
+      @command.expects(:ask_yn).returns("Y")
+      @command.options[:replaces] = 1
+      @command.expects(:create_deployment).returns([200, 2])
+    end
+
+    should "issue a replacement request to core" do
+      @mock_client.expects(:put).with(EPC::Config::DEPLOYMENTS_PATH + "/2", :stage_name => "no_change", :replaces_id => 1, :versions => "no_change").
+        returns([200, {}, {}])
+      @command.expects(:say).with("Replacement request successful")
+
+      @command.execute
+    end
+
+    should "notify if replacement request fails" do
+      @mock_client.expects(:put).with(EPC::Config::DEPLOYMENTS_PATH + "/2", :stage_name => "no_change", :replaces_id => 1, :versions => "no_change").
+        returns([500, {:message => "System exception"}, {}])
+      @command.expects(:say).with("Replacement request failed: [System exception]")
+
+      @command.execute
+    end
+    
+
+  end
+  
+  context "create_deployment" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateDeploymentCommand.new(@mock_client)
+    end
+    
+    should "return status and id if the status is 201" do
+
+      @mock_client.expects(:post).with("/api/v1/deployments",
+        { :solution_name => "Test Solution", :stage_name => "dev" }).
+        returns([201, { :id => 1 }, {}])
+      @command.expects(:say).with("Successfully created deployment [1] with [http://localhost:3000]")
+
+      status, id = @command.send(:create_deployment, "Test Solution", "dev")
+      
+      assert_equal 201, status
+      assert_equal(1, id)
+    end
+    
+    should "return status if the status is not 200" do
+    
+      @mock_client.expects(:post).with("/api/v1/deployments",
+        { :solution_name => "Test Solution", :stage_name => "dev" }).  
+        returns([404, { :message => "Not Found" }, {}])
+      @command.expects(:say).with("Deployment creation failed [Not Found]. Aborting.")
+      
+      status, id = @command.send(:create_deployment, "Test Solution", "dev")
+      
+      assert_equal 404, status
+    end
+  end
+
+  context "project parsing" do
+    setup do 
+      @mock_client = mock("Client")
+      @command = EPC::Command::CreateDeploymentCommand.new(@mock_client)
+    end
+
+    should "return blank results when passed blank data" do
+      assert_equal(@command.send(:parse_projects, []), [[], []])
+    end
+
+
+    should "parse projects" do
+      assert_equal(@command.send(:parse_projects, "1:2:3"), [[{:project_id => "1", :version => "2"}], [{:project_id => "1", :instances => "3"}]])
+    end
+  end
+end