epc 1.0.2

data/test/command/attach_library_command_test.rb

@@ -0,0 +1,124 @@
+require 'test_helper'
+
+class AttachLibraryCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "checks" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::AttachLibraryCommand.new(@mock_client)
+    end
+
+    should "fail if library not specified" do
+      assert_raise EPC::Error::FatalError do
+        assert_equal(@command.execute, 1)
+      end
+    end
+
+    should "fail if project cannot be determined" do
+      assert_raise EPC::Error::FatalError do
+        @command.expects(:infer_project_context).returns(nil) 
+        assert_equal(@command.execute("libmath"), 1)
+      end
+    end
+
+    should "fail if library id cannot be determined" do
+      assert_raise EPC::Error::InputError do
+        @command.expects(:infer_project_context).returns([1, "FirstSolution"]) 
+        @command.expects(:retrieve_libraries).returns(nil)
+
+        assert_equal(@command.execute("libmath"), 1)
+      end
+    end
+  end
+
+  context "attaching from json" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::AttachLibraryCommand.new(@mock_client)
+      @command.expects(:infer_project_context).returns([1, "FirstProject"])
+      @command.options[:file] = "path/to/json/file"
+    end
+
+    should "read data and retrieve ids" do
+      EPC::Config.expects(:read_content_as_json).returns([{"id" => 1, "name" => "libmath", "library_version" => "1.0", "group" => "math_libs"}])
+      @command.expects(:retrieve_libraries).returns([1])
+      @mock_client.expects(:post).returns([200, {}, {}])
+      @command.expects(:say).with("Library [1] attached to project.")
+      assert_equal 200, @command.execute
+    end
+
+  end
+
+  context "attaching" do  
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::AttachLibraryCommand.new(@mock_client)
+      @command.expects(:infer_project_context).returns([1, "FirstProject"])
+    end
+
+    should "retrieve libraries by parsing a pom file" do
+      @command.options[:pom] = "path/to/pom/file"
+      @command.expects(:parse_pom).returns([1])
+      @mock_client.expects(:post).returns([200, {}, {}])
+      @command.expects(:say).with("Library [1] attached to project.")
+      assert_equal 200, @command.execute
+    end
+
+    should "fail if status is not 200" do
+      @mock_client.expects(:post).with(EPC::Config::PROJECTS_PATH + "/1/attach_library/1").
+        returns([404, {:message => "Not Found"}, {}])
+      @command.expects(:say).with("Failed to attach library [1]: [Not Found]")
+
+      assert_equal(@command.execute(1), 404)
+    end
+
+    should "attach the library to the project" do
+      @mock_client.expects(:post).with(EPC::Config::PROJECTS_PATH + "/1/attach_library/1").
+        returns([201, {}, {}])
+      @command.expects(:say).with("Library [1] attached to project.")
+
+      assert_equal(@command.execute(1), 201)
+    end
+
+    should "attach library by name, version and group" do
+      @command.expects(:retrieve_libraries).returns([1])
+      @mock_client.expects(:post).with(EPC::Config::PROJECTS_PATH + "/1/attach_library/1").
+        returns([201, {}, {}])
+      @command.expects(:say).with("Library [1] attached to project.")
+
+      assert_equal(@command.execute("math.lib", "2.0.1", "math-libs"), 201)
+    end
+  end
+
+  context "parse pom" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::AttachLibraryCommand.new(@mock_client)
+      @file = File.new(File.join(File.expand_path("."), "path_to_pom"), "w+")
+    end
+
+    teardown do
+      File.delete(@file) if FileTest.exist?(@file)
+    end
+
+    should "throw exception if can't read the file" do
+      assert_raise EPC::Error::FatalError do
+        @command.send(:parse_pom, "path/to/pom")
+      end
+    end
+
+    should "throw exception if it encounters a malformed/invalid xml file" do
+      assert_raise EPC::Error::FatalError do
+        File.expects(:read).with(File.expand_path("path_to_pom")).returns(@file)
+        REXML::Document.expects(:new).with(@file).raises(REXML::ParseException)
+        @command.send(:parse_pom, "path_to_pom")
+      end
+    end
+
+    should "parse and retrieve library ids" do
+      @command.expects(:retrieve_libraries).returns([1,2,3])
+      assert_equal @command.send(:parse_pom, "test/test_files/pom.xml"), [1,2,3]
+    end
+  end
+end

data/test/command/attach_libraryset_command_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class AttachLibrarysetCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "pre-execution checks" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::AttachLibrarysetCommand.new(@mock_client)
+    end
+
+    should "fail if can't determine project context" do
+      assert_raise EPC::Error::InputError do
+        @command.expects(:infer_solution_context).returns([1, "FirstSolution"])
+        @command.expects(:infer_project_context).returns(nil)
+        assert_equal(@command.execute(1), 1)
+      end
+    end
+  end
+
+  context "attaching/detaching" do  
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::AttachLibrarysetCommand.new(@mock_client)
+      @command.expects(:infer_solution_context).returns([1, "FirstSolution"])
+      @command.expects(:infer_project_context).returns([1, "FirstProject"])
+    end
+
+    should "issue the request to the server" do
+      @mock_client.expects(:post).with(EPC::Config::PROJECTS_PATH + "/1/attach_set/1").returns([201, {}, {}])
+      @command.expects(:say).with("Library set attached")
+      assert_equal(@command.execute(1), 201)
+    end
+
+    should "issue a detach request when detach option is true" do
+      @command.options[:detach] = true
+      @mock_client.expects(:delete).with(EPC::Config::PROJECTS_PATH + "/1/detach_set/1").returns([201, {}, {}])
+      @command.expects(:say).with("Library set detached")
+      assert_equal(@command.execute(1), 201)
+    end
+
+    should "fail if status is not successful" do
+      @mock_client.expects(:post).with(EPC::Config::PROJECTS_PATH + "/1/attach_set/1").returns([404, {:message => "Not Found"}, {}])
+      @command.expects(:say).with("Request failed: [Not Found]")
+      assert_equal(@command.execute(1), 404)
+    end
+  end
+
+end

data/test/command/attach_runtime_command_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class AttachRuntimeCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "attaching" do  
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::AttachRuntimeCommand.new(@mock_client)
+    end
+
+
+    should "fail if no project id specified or could not be determined" do
+      @command.options[:stage] = "development"
+      @command.expects(:infer_project_context).returns(nil)
+
+      assert_raise EPC::Error::InputError do
+        assert_equal(@command.execute(1), 1)
+      end
+    end
+
+    should "fail if status is not 200" do
+      @command.options[:stage] = "development"
+      @command.expects(:infer_project_context).returns([1, "FirstProject"])
+      @mock_client.expects(:put).with(EPC::Config::PROJECTS_PATH + "/1/set_runtime_env", 
+                                      {:runtime_env_id => 1, :stage_name => 'development'}).
+        returns([404, {:message => "Not Found"}, {}])
+      @command.expects(:say).with("Request failed: [Not Found]")
+
+      assert_equal(@command.execute(1), 404)
+    end
+
+    should "attach the runtime from the project" do
+      @command.options[:stage] = "development"
+      @command.expects(:infer_project_context).returns([1, "FirstProject"])
+      @mock_client.expects(:put).with(EPC::Config::PROJECTS_PATH + "/1/set_runtime_env",
+                                      {:runtime_env_id => 1, :stage_name => 'development'}).
+        returns([201, {}, {}])
+      @command.expects(:say).with("Runtime attached")
+
+      assert_equal(@command.execute(1), 201)
+    end
+  end
+end

data/test/command/base_command_test.rb

@@ -0,0 +1,276 @@
+require 'test_helper'
+require 'fileutils'
+
+class BaseCommandTest < Test::Unit::TestCase
+
+  context "translate_status_to_exit_code" do
+    setup do
+      mock_client = mock('Client')
+      @command = EPC::Command::BaseCommand.new(mock_client)
+    end
+
+    should "return 0 for statuses in the 2xx range" do
+      exit_code = @command.send(:translate_status_to_exit_code, 250)
+      assert_equal 0, exit_code
+    end
+
+    should "return the status otherwise" do
+      [0, 1, 404].each do |code|
+        exit_code = @command.send(:translate_status_to_exit_code, code)
+        assert_equal code, exit_code
+      end
+    end
+
+  end
+
+  context "resource id retrieval" do
+    setup do
+      @mock_client = mock('Client')
+      @command = EPC::Command::BaseCommand.new(@mock_client)
+      @url = EPC::Config::SOLUTIONS_PATH
+    end
+
+    should "fail if status != 200" do
+      @mock_client.expects(:get).with(@url).returns([400, {:message => "Not Found"}, {}])
+
+      assert_raise EPC::Error::InputError do
+        @command.send(:get_resource_id, @url, :name, "Sol1")
+      end
+    end
+
+    should "retrieve id from the response" do
+      @mock_client.expects(:get).with(@url).returns([200, [{:id => 1, :name => "Sol1"}, {:id => 2, :name => "Sol2"}], {}])
+      id = @command.send(:get_resource_id, @url, :name, "Sol1")
+      assert_equal id, 1
+    end
+
+  end
+
+  context "infer solution context" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::BaseCommand.new(@mock_client)
+      @path = File.expand_path(".")
+      @project_path = File.expand_path("./..")
+    end
+
+    context "s_identifier nil" do
+      should "read it from the solution directory" do
+        EPC::Config.expects(:is_solution_dir?).returns(true)
+        EPC::Config.expects(:get_solution_value).with(@path, "id").returns(1)
+        EPC::Config.expects(:get_solution_value).with(@path, "name").returns("FirstSolution")
+        result = @command.send(:infer_solution_context, nil, @path)
+        assert_equal(result, [1, "FirstSolution"])
+      end
+
+      should "read it from the project directory" do
+        EPC::Config.expects(:is_project_dir?).returns(true)
+        @command.expects(:project_solution_path).returns(@project_path)
+        EPC::Config.expects(:get_solution_value).with(@project_path, "id").returns(1)
+        EPC::Config.expects(:get_solution_value).with(@project_path, "name").returns("FirstSolution")
+        result = @command.send(:infer_solution_context, nil, @path)
+        assert_equal(result, [1, "FirstSolution"])
+      end
+    end
+
+    context "s_identifier present" do
+
+      context "numeric s_identifier" do
+        should "just return s_identifier" do
+          sol_id = @command.send(:infer_solution_context, 1, @path)
+          assert_equal([1, nil], sol_id)
+        end
+
+        should "query for solution name when option is passed" do
+          @command.expects(:get_resource_name).returns("FirstSolution")
+          sol_id, sol_name = @command.send(:infer_solution_context, 1, @path, :get_solution_name => true)
+          assert_equal(sol_id, 1)
+          assert_equal(sol_name, "FirstSolution")
+        end
+      end
+
+      context "alphanumeric s_identifier" do
+        should "read the id from solution metadata if names coincide and directory is a solution directory" do
+          EPC::Config.expects(:is_solution_dir?).returns(true)
+          EPC::Config.expects(:get_solution_value).with(@path, "name").returns("FirstSolution")
+          EPC::Config.expects(:get_solution_value).with(@path, "id").returns(1)
+          EPC::Config.expects(:get_solution_value).with(@path, "name").returns("FirstSolution")
+          results = @command.send(:infer_solution_context, "FirstSolution", @path)
+          assert_equal(results, [1, "FirstSolution"])
+        end
+
+        should "read the id from solution metadata if directory is a project directory" do
+          EPC::Config.expects(:is_solution_dir?).returns(false)
+          EPC::Config.expects(:is_project_dir?).returns(true)
+          @command.expects(:project_solution_path).with(@path).returns("a_new_path")
+          EPC::Config.expects(:get_solution_value).with("a_new_path", "name").returns("FirstSolution")
+          EPC::Config.expects(:get_solution_value).with("a_new_path", "id").returns(1)
+          EPC::Config.expects(:get_solution_value).with("a_new_path", "name").returns("FirstSolution")
+
+          results = @command.send(:infer_solution_context, "FirstSolution", @path)
+          assert_equal(results, [1, "FirstSolution"])
+        end
+
+        should "query for the solution id if it can't determine id from metadata" do
+          EPC::Config.expects(:is_solution_dir?).returns(false)
+          EPC::Config.expects(:is_project_dir?).returns(false)
+          @command.expects(:get_resource_id).returns(1)
+          results = @command.send(:infer_solution_context, "FirstSolution", @path)
+          assert_equal(results, [1, "FirstSolution"])
+        end
+      end
+
+    end
+  end
+
+  context "infer project context" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::BaseCommand.new(@mock_client)
+      @path = File.expand_path(".")
+      @solution_path = File.expand_path("./..")
+    end
+
+    context "s_identifier nil" do
+
+      should "read it from the project directory" do
+        EPC::Config.expects(:is_project_dir?).returns(true)
+        EPC::Config.expects(:get_project_value).with(@path, "id").returns(1)
+        EPC::Config.expects(:get_project_value).with(@path, "name").returns("FirstProject")
+        result = @command.send(:infer_project_context, nil, @path)
+        assert_equal(result, [1, "FirstProject"])
+      end
+    end
+
+    context "p_identifier present" do
+
+      context "numeric p_identifier" do
+        should "just return p_identifier" do
+          p_id = @command.send(:infer_project_context, 1, @path)
+          assert_equal([1, nil], p_id)
+        end
+
+        should "query for  project name when option is passed" do
+          @command.expects(:get_resource_name).returns("FirstProject")
+          p_id, p_name = @command.send(:infer_project_context, 1, @path, 1, :get_project_name => true)
+          assert_equal(p_id, 1)
+          assert_equal(p_name, "FirstProject")
+        end
+      end
+
+      context "alphanumeric p_identifier" do
+        should "query for the project id if a solution identifier has been passed" do
+          @command.expects(:get_resource_id).returns(1)
+          results = @command.send(:infer_project_context, "FirstProject", @path, 1)
+          assert_equal(results, [1, "FirstProject"])
+        end
+
+        should "read the id from project metadata if names coincide and directory is the parent solution directory" do
+          EPC::Config.expects(:is_solution_dir?).with(@path).returns(true)
+          File.expects(:join).with(@path, "FirstProject").returns("project_path")
+          File.expects(:exists?).with("project_path").returns(true)
+          EPC::Config.expects(:get_project_value).with("project_path", "id").returns(1)
+          results = @command.send(:infer_project_context, "FirstProject", @path, nil, {})
+          assert_equal(results, [1, "FirstProject"])
+        end
+
+        should "read the id from project metadata if names coincide and directory is a project directory" do
+          EPC::Config.expects(:is_solution_dir?).with(@path).returns(false)
+          EPC::Config.expects(:is_project_dir?).with(@path).returns(true)
+          EPC::Config.expects(:get_project_value).with(@path, "name").returns("FirstProject")
+          EPC::Config.expects(:get_project_value).with(@path, "id").returns(1)
+          results = @command.send(:infer_project_context, "FirstProject", @path, nil, {})
+          assert_equal(results, [1, "FirstProject"])
+        end
+      end
+
+    end
+  end
+
+  context "library retrieval" do
+    setup do
+      @mock_client = mock('Client')
+      @command = EPC::Command::BaseCommand.new(@mock_client)
+    end
+
+    should "fail if library retrieval from server fails" do
+      assert_raise EPC::Error::FatalError do
+        @mock_client.expects(:get).with(EPC::Config::LIBRARIES_PATH).returns([500, {:message => "System exception"}, {}])
+        @command.send(:retrieve_libraries, [{}])
+      end
+    end
+
+    should "fail if a library can't be found" do
+      assert_raise EPC::Error::FatalError do
+        @mock_client.expects(:get).with(EPC::Config::LIBRARIES_PATH).
+          returns(
+            [200, [{:id => 2, :name => "lib2", :group => "grp", :library_version => "1"}], {}]
+          )
+        @command.send(:retrieve_libraries, [{:name => "lib1", :library_version => "1.2", :group => "grp"}])
+      end
+    end
+
+    should "return library ids" do
+      @mock_client.expects(:get).with(EPC::Config::LIBRARIES_PATH).
+        returns(
+          [200, [{:id => 2, :name => "lib1", :group => "grp", :library_version => "1.2"}], {}]
+      )
+      assert_equal @command.send(:retrieve_libraries, [{:name => "lib1", :library_version => "1.2", :group => "grp"}]), [2]
+    end
+  end
+
+
+  context "show_build_status" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::BaseCommand.new(@mock_client)
+    end
+    
+    should "return true, id, built and message if the status is 200" do
+      @mock_client.expects(:get).with("/api/v1/builds/7/status").
+        returns([200, { :id => 1, :built => true, :message => 'Success' }, {}])
+
+      created, id, built, message = @command.send(:show_build_status, 7)
+      
+      assert(created)
+      assert_equal(1, id)
+      assert(built)
+    end
+    
+    should "return false if the status is not 200" do
+      @mock_client.expects(:get).with("/api/v1/builds/7/status").
+        returns([404, { :message => "Not Found" }, {}])
+      
+      created, id, built, message = @command.send(:show_build_status, 7)
+      
+      assert(!created)
+    end
+  end
+
+  context "poll for build status" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::BaseCommand.new(@mock_client)
+      @command.instance_variable_set(:@timeout, 5)
+    end
+
+    should "poll untill built" do
+      @command.expects(:show_build_status).with(1).returns([true, 1, "", "BUILT"])
+      @command.expects(:say).with("\nBuild completed successfully.")
+      assert_equal(@command.send(:poll_for_build_status, 1), 0)
+    end
+
+    should "poll untill failed" do
+      @command.expects(:show_build_status).with(1).returns([true, 1, "there was an error", "FAILED"])
+      @command.expects(:say).with("\nBuild failed: FAILED - there was an error")
+      assert_equal(@command.send(:poll_for_build_status, 1), 1)
+    end
+
+    should "notify when it's unable to get the build status" do
+      @command.expects(:show_build_status).with(1).returns([false, 1, "there was an error", "FAILED"])
+      @command.expects(:say).with("Poller failed to get the build status. Aborting.")
+      assert_equal(@command.send(:poll_for_build_status, 1), 1)
+    end
+
+  end
+end