epc 1.0.2

data/test/command/list_serviceversions_command_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class ListServiceversionsCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "list service versions" do
+    setup do 
+      @mock_client = mock("Client")
+
+      @command = EPC::Command::ListServiceversionsCommand.new(@mock_client) 
+    end 
+
+    should "show exception message status is not 201" do
+      @mock_client.expects(:get).with(EPC::Config::SERVICE_VERSIONS_PATH).
+        returns([400, {:message => "Not Found"}, {}])
+      @command.expects(:say).with("Request failed: [Not Found]")
+
+      assert_equal(@command.execute, 400)
+    end
+
+    should "show a message if there are no service versions" do
+
+      @mock_client.expects(:get).with(EPC::Config::SERVICE_VERSIONS_PATH).
+        returns([200, {}, {}])
+
+      @command.expects(:say).returns("No service-versions have been defined.")
+      @command.expects(:say).returns("You can define one with epc create service-version.")
+
+      assert_equal(@command.execute, 200)
+    end
+
+    should "list available service versions" do
+      @mock_client.expects(:get).with(EPC::Config::SERVICE_VERSIONS_PATH).
+        returns([200,
+          [
+            {:id => 1, :label => "main_db"},
+            {:id => 2, :label => "main_redis"}], 
+          {}])
+      
+
+
+      @command.expects(:say).at_least_once 
+      assert_equal(@command.execute, 200)
+    end
+
+  end
+end

data/test/command/list_solutions_command_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class ListSolutionsCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "list solutions" do
+    setup do 
+      @mock_client = mock("Client")
+
+      @command = EPC::Command::ListSolutionsCommand.new(@mock_client) 
+    end 
+
+    should "show exception message status is not 201" do
+      @mock_client.expects(:get).with(EPC::Config::SOLUTIONS_PATH).
+        returns([400, {:message => "Not Found"}, {}])
+      @command.expects(:say).with("Solutions retrieval failed with [Not Found]")
+
+      assert_equal(@command.execute, 400)
+    end
+
+    should "show a message if there are no solutions" do
+
+      @mock_client.expects(:get).with(EPC::Config::SOLUTIONS_PATH).
+        returns([200, {}, {}])
+
+      @command.expects(:say).returns("You have no solutions created.You can create them with epc create solution.")
+
+      assert_equal(@command.execute, 200)
+    end
+
+    should "list available solutions" do
+      time1 = (Time.now - 5).to_s
+      time2 = Time.now.to_s
+      @mock_client.expects(:get).with(EPC::Config::SOLUTIONS_PATH).
+        returns([200,
+          [
+            {:id => 1, :name => "Solution1", :created_at => time1 },
+            {:id => 2, :name => "Solution2", :created_at => time2 }], 
+          {}])
+      
+
+
+      @command.expects(:say).at_least_once 
+      assert_equal(@command.execute, 200)
+    end
+
+  end
+end

data/test/command/list_users_command_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class ListUsersCommandTest < Test::Unit::TestCase
+  should_require_login
+
+
+  context "execution" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::ListUsersCommand.new(@mock_client)
+    end
+
+    should "fail if status is not 200(ok)" do
+      @mock_client.expects(:get).with(EPC::Config::USERS_PATH).returns([500, {:message => "System exception encountered"}, {}])
+      @command.expects(:say).with("Request failed: [System exception encountered]")
+      assert_equal 500, @command.execute
+    end
+
+    should "show a message if no users are defined" do
+      @mock_client.expects(:get).with(EPC::Config::USERS_PATH).returns([200, {}, {}])
+      @command.expects(:say).with("No users defined")
+      assert_equal 200, @command.execute
+    end
+
+    should "list users" do
+
+      @mock_client.expects(:get).with(EPC::Config::USERS_PATH).returns([200, [ {:id => 1, :name => "user1", :email => "user1@epaas.com", :created_at => Time.now.to_s}],  {}])
+      @command.expects(:say)
+      assert_equal 200, @command.execute
+    end
+  end
+
+end

data/test/command/login_command_test.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+class LoginCommandTest < Test::Unit::TestCase
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @mock_config = mock("Config")
+      
+      EPC::Config.target_file = '~/.epc_test_target'
+    end
+    
+    should "prompt for password" do
+      command = EPC::Command::LoginCommand.new(@mock_client)
+      command.expects(:ask).with("Password: ").returns("testpass")
+    
+      @mock_client.expects(:post).with("/api/v1/tokens/retrieve", { :email => 'me@there.com', :password => 'testpass' }, true).returns(201, {}, {})
+      
+      assert_equal(command.execute("me@there.com"), 201)
+    end
+    
+    should "use the password passed to initialize" do
+      command = EPC::Command::LoginCommand.new(@mock_client, :password => 'testpass')
+      command.expects(:ask).with("Password: ").never
+      
+      @mock_client.expects(:post).with("/api/v1/tokens/retrieve", { :email => 'me@there.com', :password => 'testpass' }, true).returns(201, {}, {})
+      
+      assert_equal(command.execute("me@there.com"), 201)
+    end
+    
+    should "report failure if email was not provided" do
+      command = EPC::Command::LoginCommand.new(@mock_client, :password => 'testpass')
+      command.expects(:ask).with("Password: ").never
+      
+      @mock_client.expects(:post).never
+      command.expects(:say).with("You must supply an email address")
+      
+      assert_equal(command.execute, 1)
+    end
+    
+    should "store caller_id and auth_token and email if the status is 201" do
+      command = EPC::Command::LoginCommand.new(@mock_client, :password => 'testpass')
+      command.expects(:ask).with("Password: ").never
+      
+      @mock_client.expects(:post).
+        with("/api/v1/tokens/retrieve", { :email => 'me@there.com', :password => 'testpass' }, true).
+        returns([201, { :caller_id => '123', :authentication_token => 'abcdef' }, {}])
+      command.expects(:say).with("Successfully logged into [http://localhost:3000]")
+        
+      EPC::Config.expects(:store_caller_id).with('123')
+      EPC::Config.expects(:store_auth_token).with('abcdef')
+      EPC::Config.expects(:store_username).with('me@there.com')
+
+      assert_equal(command.execute("me@there.com"), 201)
+    end
+    
+    should "not store caller_id and auth_token and email if the status is not 201" do
+      command = EPC::Command::LoginCommand.new(@mock_client, :password => 'testpass')
+      command.expects(:ask).with("Password: ").never
+      
+      @mock_client.expects(:post).
+        with("/api/v1/tokens/retrieve", { :email => 'me@there.com', :password => 'testpass' }, true).
+        returns([403, { :message => "login failed" }, {}])
+      command.expects(:say).with("Login failed [login failed]. Please make sure you entered the correct email and password.")
+        
+      EPC::Config.expects(:store_caller_id).never
+      EPC::Config.expects(:store_auth_token).never
+      EPC::Config.expects(:store_username).never
+
+      assert_equal(command.execute("me@there.com"), 403)
+    end
+    
+    should "report error if the call throws an exception" do
+      command = EPC::Command::LoginCommand.new(@mock_client, :password => 'testpass')
+      
+      @mock_client.expects(:post).
+        with("/api/v1/tokens/retrieve", { :email => 'me@there.com', :password => 'testpass' }, true).
+        raises(StandardError.new("failed"))
+      command.expects(:say).with("Login failed [failed].")
+      
+      assert_equal(command.execute("me@there.com"), 1)
+    end
+  end 
+end

data/test/command/logout_command_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class LogoutCommandTest < Test::Unit::TestCase
+  should_require_login
+
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @mock_config = mock("Config")
+    end
+    
+    should "remove the auth_token and user if the status is 200" do
+      command = EPC::Command::LogoutCommand.new(@mock_client)
+    
+      EPC::Config.expects(:remove_auth_token).returns(true)
+      EPC::Config.expects(:remove_username)
+      command.expects(:say)
+      assert_equal(command.execute, 0)
+    end
+
+    should "notify when logout fails" do
+      command = EPC::Command::LogoutCommand.new(@mock_client)
+    
+      EPC::Config.expects(:remove_auth_token).returns(false)
+      command.expects(:say)
+      assert_equal(command.execute, 1)
+    end
+
+  end
+end

data/test/command/pull_command_test.rb

@@ -0,0 +1,229 @@
+require 'test_helper'
+
+class PullCommandTest < Test::Unit::TestCase
+  context "execute" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::PullCommand.new(@mock_client)
+    end
+
+    should "fail if solution name can't be inferred" do
+      @command.expects(:get_resource_name).returns(nil)
+      EPC::Config.expects(:is_solution_dir?).returns(false)
+      EPC::Config.expects(:is_project_dir?).returns(false)
+      assert_raise EPC::Error::FatalError do
+        assert_equal(@command.execute(1), 1)
+      end
+    end
+
+    should "prompt the user before pulling" do
+      @command.expects(:ask_yn).returns("N")
+      assert_equal(@command.execute("FirstSolution"), 1)
+    end
+
+    should "create a directory for new solutions" do
+      @command.expects(:get_resource_name).returns("FirstSolution")
+      # EPC::Config.expects(:is_solution_dir?).returns(false)
+      EPC::Config.expects(:is_project_dir?).returns(false)
+      @command.expects(:ask_yn).returns("Y")
+      @command.expects(:create_pull).returns([200, 1])
+      @command.expects(:prep_solution_directory).returns(true)
+      @command.expects(:say)
+      @command.expects(:poll_for_pull_url).returns([true, "url_to_zip"])
+      Dir.expects(:tmpdir).returns("tmp_dir")
+      @command.expects(:pull_zip).with("url_to_zip", "tmp_dir").returns([true, "path_to_zip"])
+      @command.expects(:unzip_solution)
+      @command.expects(:confirm_pull)
+      refresh_command = EPC::Command::RefreshSolutionCommand.new(@mock_client)
+      EPC::Command::RefreshSolutionCommand.expects(:new).returns(refresh_command)
+      refresh_command.expects(:execute).returns(0)
+      assert_equal(@command.execute(1), 0)
+    end
+  end
+
+
+  context "create_pull" do
+    setup do
+      @mock_client = mock("Client")
+      EPC::Config.target_file = '~/.epc_test_target'
+    end
+    
+    should "return true and id if the status is 201" do
+      command = EPC::Command::PullCommand.new(@mock_client)
+
+      @mock_client.expects(:post).with("/api/v1/pulls", { :solution_name => "Test Solution" }).
+        returns([202, { :id => 1 }, {}])
+      command.expects(:say).with("Successfully created a pull with [http://localhost:3000]")
+
+      status, id = command.send(:create_pull, "Test Solution")
+      
+      assert_equal 202, status
+      assert_equal(1, id)
+    end
+    
+    should "return false if the status is not 202" do
+      command = EPC::Command::PullCommand.new(@mock_client)
+    
+      @mock_client.expects(:post).with("/api/v1/pulls", { :solution_name => "Test Solution" }).  
+        returns([404, { :message => "Not Found" }, {}])
+      command.expects(:raise).with(Exception, "Not Found")
+      
+      status, id = command.send(:create_pull, "Test Solution")
+      
+      assert_equal 404, status
+    end
+  end
+  
+  context "confirm_pull" do
+    setup do
+      @mock_client = mock("Client")
+      
+      EPC::Config.target_file = '~/.epc_test_target'
+    end
+    
+    should "return true if the status is 200" do
+      command = EPC::Command::PullCommand.new(@mock_client)
+
+      @mock_client.expects(:put).with("/api/v1/pulls/1/confirm", { :pulled => 'yes' }).
+        returns([200, { :id => 1 }, {}])
+      command.expects(:say).with("Successfully confirmed the pull with [http://localhost:3000]")
+
+      confirmed = command.send(:confirm_pull, 1)
+      
+      assert(confirmed)
+    end
+    
+    should "return false if the status is not 200" do
+      command = EPC::Command::PullCommand.new(@mock_client)
+
+      @mock_client.expects(:put).with("/api/v1/pulls/1/confirm", { :pulled => 'yes' }).
+        returns([400, { :message => "bad request" }, {}])
+      command.expects(:say).with("Pull confirmation failed [bad request].")
+
+      confirmed = command.send(:confirm_pull, 1)
+      
+      assert(!confirmed)
+    end
+  end
+  
+  context "sign_pull" do
+    setup do
+      @mock_client = mock("Client")
+    end
+    
+    should "return true if the status is 200" do
+      command = EPC::Command::PullCommand.new(@mock_client)
+
+      @mock_client.expects(:put).with("/api/v1/pulls/1/sign").
+        returns([200, { :signed_url => "http://download/from/here" }, {}])
+
+      status, code, url = command.send(:sign_pull, 1)
+      
+      assert_equal(200, status)
+      assert_nil(code)
+      assert_equal("http://download/from/here", url)
+    end
+
+    should "return false if the status is not 200" do
+      command = EPC::Command::PullCommand.new(@mock_client)
+
+      @mock_client.expects(:put).with("/api/v1/pulls/1/sign").
+        returns([404, { :message => "not found", :error_code => 801 }, {}])
+
+      status, code, url = command.send(:sign_pull, 1)
+    
+      assert_equal(404, status)
+      assert_equal(801, code)
+      assert_nil(url)
+    end
+  end
+
+  context "prep_solution_directory" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::PullCommand.new(@mock_client)
+    end
+
+    should "notify if solutions wasn't found" do
+      @command.expects(:get_resource_id).returns(nil)
+      @command.expects(:say).returns("Solution not found")
+      assert_equal(@command.send(:prep_solution_directory, "path_to_dir", "FirstSolution"), false)
+
+    end
+
+    should "notify if directory creation fails" do
+      @command.expects(:get_resource_id).returns(1)
+      Dir.expects(:mkdir).raises(Exception)
+      @command.expects(:say)
+      assert_equal(@command.send(:prep_solution_directory, "path_to_dir", "FirstSolution"), false)
+    end
+
+    should "notify if metadata file can't be created" do
+      @command.expects(:get_resource_id).returns(1)
+      Dir.expects(:mkdir)
+      File.expects(:open).raises(Exception)
+      @command.expects(:say)
+      assert_equal(@command.send(:prep_solution_directory, "path_to_dir", "FirstSolution"), false)
+    end
+  end
+
+  context "poll for pull url" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::PullCommand.new(@mock_client)
+    end
+
+    should "poll untill if receives and url" do
+      @command.expects(:sign_pull).returns([200, 1, "url_to_zip"])
+      assert_equal(@command.send(:poll_for_pull_url, 1), [true, "url_to_zip"])
+    end
+
+    should "notify when there's an error in polling" do
+      @command.expects(:sign_pull).returns([500, 1, nil])
+      @command.expects(:say).with("Poller failed to get the pull URL. Aborting.")
+      assert_equal(@command.send(:poll_for_pull_url, 1), [false, nil])
+    end
+
+  end
+
+  context "check pull" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::PullCommand.new(@mock_client)
+    end
+
+    should "fail if path doesn't exists" do
+      File.expects(:exists?).returns(false)
+      @command.expects(:say).with("Pull path does not exist")
+      @command.send(:check_pull_directory, "path")
+    end
+
+    should "fail if path isn't a directory" do
+      File.expects(:exists?).returns(true)
+      File.expects(:directory?).returns(false)
+      @command.expects(:say).with("Pull path is not a directory")
+      @command.send(:check_pull_directory, "path")
+    end
+  end
+
+  context "pull zip" do
+    setup do
+      @mock_client = mock("Client")
+      @command = EPC::Command::PullCommand.new(@mock_client)
+    end
+
+    should "pull the zip" do
+      @command.send(:http_client).expects(:get).returns([200, "response", {}])
+      @command.expects(:say).with("Successfully pulled the zip file from the build repository")
+      @command.expects(:open)
+      
+      @command.send(:pull_zip, "url", "path_to_zip")
+    end
+
+    should "notify if pull fails" do
+      @command.send(:http_client).expects(:get).returns([500, "response", {}])
+      @command.expects(:say).with("Failed to pull the zip file from the build repository [status = 500]. Aborting pull command.")
+      @command.send(:pull_zip, "url", "path_to_zip")
+    end
+  end
+end