tddium-preview 0.0.4 → 0.0.5

data/Gemfile.lock

@@ -1,10 +1,10 @@
 PATH
   remote: .
   specs:
-    tddium-preview (0.0.3)
+    tddium-preview (0.0.5)
       highline
       json
-      tddium_client (= 0.0.3)
+      tddium_client (>= 0.0.6)
       thor
 
 GEM
@@ -29,7 +29,7 @@ GEM
     simplecov (0.4.1)
       simplecov-html (~> 0.4.3)
     simplecov-html (0.4.3)
-    tddium_client (0.0.3)
+    tddium_client (0.0.6)
       httparty
       json
     thor (0.14.6)

data/lib/tddium.rb

@@ -37,10 +37,9 @@ class Tddium < Thor
   method_option :ssh_key_file, :type => :string, :default => nil
   def account
     set_default_environment(options[:environment])
-    if user_logged_in? do |api_response|
-        # User is already logged in, so just display the info
-        show_user_details(api_response)
-      end
+    if user_details = user_logged_in?
+      # User is already logged in, so just display the info
+      show_user_details(user_details)
     else
       params = get_user_credentials(options.merge(:invited => true))
 
@@ -65,11 +64,15 @@ class Tddium < Thor
       license_accepted = ask(Text::Prompt::LICENSE_AGREEMENT)
       return unless license_accepted.downcase == Text::Prompt::Response::AGREE_TO_LICENSE.downcase
 
-      api_result = call_api(:post, Api::Path::USERS, {:user => params}, false, false) do |api_response|
-        write_api_key(api_response["user"]["api_key"])
-        say Text::Process::ACCOUNT_CREATED % [api_response["user"]["email"], api_response["user"]["recurly_url"]]
+      begin
+        new_user = call_api(:post, Api::Path::USERS, {:user => params}, false, false)
+        write_api_key(new_user["user"]["api_key"])
+        say Text::Process::ACCOUNT_CREATED % [new_user["user"]["email"], new_user["user"]["recurly_url"]]
+      rescue TddiumClient::Error::API => e
+        say((e.status == Api::ErrorCode::INVALID_INVITATION) ? Text::Error::INVALID_INVITATION : e.message)
+      rescue TddiumClient::Error::Base => e
+        say e.message
       end
-      say((api_result.api_status == Api::ErrorCode::INVALID_INVITATION) ? Text::Error::INVALID_INVITATION : api_result.message) unless api_result.success?
     end
   end
 
@@ -82,9 +85,7 @@ class Tddium < Thor
     if user_logged_in?
       say Text::Process::ALREADY_LOGGED_IN
     else
-      login_user(:params => get_user_credentials(options), :show_error => true) do
-        say Text::Process::LOGGED_IN_SUCCESSFULLY
-      end
+      say Text::Process::LOGGED_IN_SUCCESSFULLY if login_user(:params => get_user_credentials(options), :show_error => true)
     end
   end
 
@@ -108,72 +109,63 @@ class Tddium < Thor
     return unless git_push
 
     # Call the API to get the suite and its tests
-    call_api(:get, current_suite_path) do |api_response|
-      test_pattern = api_response["suite"]["test_pattern"]
+    begin
+      suite_details = call_api(:get, current_suite_path)
+      test_pattern = suite_details["suite"]["test_pattern"]
       test_files = Dir.glob(test_pattern).collect {|file_path| {:test_name => file_path}}
 
       # Create a session
-      call_api(:post, Api::Path::SESSIONS) do |api_response|
-        session_id = api_response["session"]["id"]
-
-        # Call the API to register the tests
-        call_api(:post, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::REGISTER_TEST_EXECUTIONS}", {:suite_id => current_suite_id, :tests => test_files}) do |api_response|
-          # Start the tests
-          call_api(:post, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::START_TEST_EXECUTIONS}") do |api_response|
-            tests_not_finished_yet = true
-            finished_tests = {}
-            test_statuses = Hash.new(0)
-            api_call_successful = true
-            get_test_executions_response = {}
-
-            say Text::Process::STARTING_TEST % test_files.size
-            say Text::Process::TERMINATE_INSTRUCTION
-            while tests_not_finished_yet && api_call_successful do
-              # Poll the API to check the status
-              call_api_result = call_api(:get, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::TEST_EXECUTIONS}") do |api_response|
-                # Catch Ctrl-C to interrupt the test
-                Signal.trap(:INT) do
-                  say Text::Process::INTERRUPT
-                  say Text::Process::CHECK_TEST_STATUS
-                  tests_not_finished_yet = false
-                end
-
-                # Print out the progress of running tests
-                api_response["tests"].each do |test_name, result_params|
-                  test_status = result_params["status"]
-                  if result_params["end_time"] && !finished_tests[test_name]
-                    message = case test_status
-                                when "passed" then [".", :green, false]
-                                when "failed" then ["F", :red, false]
-                                when "error" then ["E", nil, false]
-                                when "pending" then ["*", :yellow, false]
-                              end
-                    finished_tests[test_name] = test_status
-                    test_statuses[test_status] += 1
-                    say *message
-                  end
-                end
-
-                # save response for later use
-                get_test_executions_response = api_response
-
-                # If all tests finished, exit the loop else sleep
-                if finished_tests.size == api_response["tests"].size
-                  tests_not_finished_yet = false
-                else
-                  sleep(Default::SLEEP_TIME_BETWEEN_POLLS)
-                end
-              end
-              api_call_successful = call_api_result.success?
-            end
+      new_session = call_api(:post, Api::Path::SESSIONS)
+      session_id = new_session["session"]["id"]
+
+      # Register the tests
+      call_api(:post, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::REGISTER_TEST_EXECUTIONS}", {:suite_id => current_suite_id, :tests => test_files})
+
+      # Start the tests
+      start_test_executions = call_api(:post, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::START_TEST_EXECUTIONS}")
+      tests_not_finished_yet = true
+      finished_tests = {}
+      test_statuses = Hash.new(0)
+
+      say Text::Process::STARTING_TEST % test_files.size
+      say Text::Process::CHECK_TEST_REPORT % start_test_executions["report"]
+      say Text::Process::TERMINATE_INSTRUCTION
+      while tests_not_finished_yet do
+        # Poll the API to check the status
+        current_test_executions = call_api(:get, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::TEST_EXECUTIONS}")
+
+        # Catch Ctrl-C to interrupt the test
+        Signal.trap(:INT) do
+          say Text::Process::INTERRUPT
+          say Text::Process::CHECK_TEST_STATUS
+          tests_not_finished_yet = false
+        end
 
-            # Print out the result
-            say Text::Process::FINISHED_TEST % (Time.now - start_time)
-            say "#{finished_tests.size} examples, #{test_statuses["failed"]} failures, #{test_statuses["error"]} errors, #{test_statuses["pending"]} pending"
-            say Text::Process::CHECK_TEST_REPORT % get_test_executions_response["report"]
+        # Print out the progress of running tests
+        current_test_executions["tests"].each do |test_name, result_params|
+          test_status = result_params["status"]
+          if result_params["end_time"] && !finished_tests[test_name]
+            message = case test_status
+                        when "passed" then [".", :green, false]
+                        when "failed" then ["F", :red, false]
+                        when "error" then ["E", nil, false]
+                        when "pending" then ["*", :yellow, false]
+                      end
+            finished_tests[test_name] = test_status
+            test_statuses[test_status] += 1
+            say *message
           end
         end
+
+        # If all tests finished, exit the loop else sleep
+        finished_tests.size == current_test_executions["tests"].size ? tests_not_finished_yet = false : sleep(Default::SLEEP_TIME_BETWEEN_POLLS)
       end
+
+      # Print out the result
+      say " "
+      say Text::Process::FINISHED_TEST % (Time.now - start_time)
+      say "#{finished_tests.size} examples, #{test_statuses["failed"]} failures, #{test_statuses["error"]} errors, #{test_statuses["pending"]} pending"
+    rescue TddiumClient::Error::Base
     end
   end
 
@@ -183,13 +175,14 @@ class Tddium < Thor
     set_default_environment(options[:environment])
     return unless git_repo? && tddium_settings && suite_for_current_branch?
 
-    call_api(:get, Api::Path::SUITES) do |api_response|
-      if api_response["suites"].size == 0
+    begin
+      current_suites = call_api(:get, Api::Path::SUITES)
+      if current_suites["suites"].size == 0
         say Text::Status::NO_SUITE
       else
-        say Text::Status::ALL_SUITES % api_response["suites"].collect {|suite| suite["repo_name"]}.join(", ")
+        say Text::Status::ALL_SUITES % current_suites["suites"].collect {|suite| suite["repo_name"]}.join(", ")
 
-        if current_suite = api_response["suites"].detect {|suite| suite["id"] == current_suite_id}
+        if current_suite = current_suites["suites"].detect {|suite| suite["id"] == current_suite_id}
           say Text::Status::SEPARATOR
           say Text::Status::CURRENT_SUITE % current_suite["repo_name"]
 
@@ -201,6 +194,7 @@ class Tddium < Thor
           say Text::Status::CURRENT_SUITE_UNAVAILABLE
         end
       end
+    rescue TddiumClient::Error::Base
     end
   end
 
@@ -213,29 +207,27 @@ class Tddium < Thor
     return unless git_repo? && tddium_settings
 
     params = {}
-    if current_suite_id
-      call_api(:get, current_suite_path) do |api_response|
+    begin
+      if current_suite_id
+        current_suite = call_api(:get, current_suite_path)
         # Get the current test pattern and prompt for updates
-        params[:test_pattern] = prompt(Text::Prompt::TEST_PATTERN, options[:test_pattern], api_response["suite"]["test_pattern"])
+        params[:test_pattern] = prompt(Text::Prompt::TEST_PATTERN, options[:test_pattern], current_suite["suite"]["test_pattern"])
 
         # Update the current suite if it exists already
-        call_api(:put, current_suite_path, {:suite => params}) do |api_response|
-          say Text::Process::UPDATE_SUITE
-        end
-      end
-    else
-      params[:branch] = current_git_branch
-      default_suite_name = File.basename(Dir.pwd)
-      params[:repo_name] = options[:name] || default_suite_name
-
-      existing_suite = nil
-      use_existing_suite = false
-      suite_name_resolved = false
-      api_call_successful = true
-      while !suite_name_resolved && api_call_successful
-        # Check to see if there is an existing suite
-        api_call_successful = call_api(:get, Api::Path::SUITES, params) do |api_response|
-          existing_suite = api_response["suites"].first
+        call_api(:put, current_suite_path, {:suite => params})
+        say Text::Process::UPDATE_SUITE
+      else
+        params[:branch] = current_git_branch
+        default_suite_name = File.basename(Dir.pwd)
+        params[:repo_name] = options[:name] || default_suite_name
+
+        existing_suite = nil
+        use_existing_suite = false
+        suite_name_resolved = false
+        while !suite_name_resolved
+          # Check to see if there is an existing suite
+          current_suites = call_api(:get, Api::Path::SUITES, params)
+          existing_suite = current_suites["suites"].first
 
           # Get the suite name
           current_suite_name = params[:repo_name]
@@ -256,10 +248,8 @@ class Tddium < Thor
             # Suite name does not exist yet and already prompted
             suite_name_resolved = true
           end
-        end.success?
-      end
+        end
 
-      if api_call_successful
         if use_existing_suite
           # Write to file and exit when using the existing suite
           write_suite(existing_suite["id"])
@@ -274,31 +264,30 @@ class Tddium < Thor
         params[:test_pattern] = prompt(Text::Prompt::TEST_PATTERN, options[:test_pattern], Default::TEST_PATTERN)
 
         # Create new suite if it does not exist yet
-        call_api(:post, Api::Path::SUITES, {:suite => params}) do |api_response|
-          # Save the created suite
-          write_suite(api_response["suite"]["id"])
-
-          # Manage git
-          `git remote rm #{Git::REMOTE_NAME}`
-          `git remote add #{Git::REMOTE_NAME} #{api_response["suite"]["git_repo_uri"]}`
-          git_push
-        end
+        new_suite = call_api(:post, Api::Path::SUITES, {:suite => params})
+        # Save the created suite
+        write_suite(new_suite["suite"]["id"])
+
+        # Manage git
+        `git remote rm #{Git::REMOTE_NAME}`
+        `git remote add #{Git::REMOTE_NAME} #{new_suite["suite"]["git_repo_uri"]}`
+        git_push
       end
+    rescue TddiumClient::Error::Base
     end
   end
 
   private
 
-  def call_api(method, api_path, params = {}, api_key = nil, show_error = true, &block)
+  def call_api(method, api_path, params = {}, api_key = nil, show_error = true)
     api_key =  tddium_settings(:fail_with_message => false)["api_key"] if tddium_settings(:fail_with_message => false) && api_key != false
-    api_status, http_status, error_message = tddium_client.call_api(method, api_path, params, api_key, &block)
-    say error_message if error_message && show_error
-    response = Struct.new(:api_status, :http_status, :message) do
-      def success?
-        self.api_status.to_i.zero?
-      end
+    begin
+      result = tddium_client.call_api(method, api_path, params, api_key)
+    rescue TddiumClient::Error::Base => e
+      say e.message if show_error
+      raise e
     end
-    response.new(api_status, http_status, error_message)
+    result
   end
 
   def current_git_branch
@@ -324,11 +313,11 @@ class Tddium < Thor
   end
 
   def environment
-    tddium_client.environment
+    tddium_client.environment.to_sym
   end
 
-  def get_user(&block)
-    call_api(:get, Api::Path::USERS, {}, nil, false, &block)
+  def get_user
+    call_api(:get, Api::Path::USERS, {}, nil, false) rescue nil
   end
 
   def get_user_credentials(options = {})
@@ -355,12 +344,13 @@ class Tddium < Thor
     message.nil?
   end
 
-  def login_user(options = {}, &block)
+  def login_user(options = {})
     # POST (email, password) to /users/sign_in to retrieve an API key
-    login_result = call_api(:post, Api::Path::SIGN_IN, {:user => options[:params]}, false, options[:show_error]) do |api_response|
+    begin
+      login_result = call_api(:post, Api::Path::SIGN_IN, {:user => options[:params]}, false, options[:show_error])
       # On success, write the API key to "~/.tddium.<environment>"
-      write_api_key(api_response["api_key"])
-      yield api_response if block_given?
+      write_api_key(login_result["api_key"])
+    rescue TddiumClient::Error::Base
     end
     login_result
   end
@@ -380,20 +370,21 @@ class Tddium < Thor
   end
 
   def show_session_details(params, no_session_prompt, all_session_prompt)
-    call_api(:get, Api::Path::SESSIONS, params) do |api_response|
+    begin
+      current_sessions = call_api(:get, Api::Path::SESSIONS, params)
       say Text::Status::SEPARATOR
-      if api_response["sessions"].size == 0
+      if current_sessions["sessions"].size == 0
         say no_session_prompt
       else
         say all_session_prompt
-        api_response["sessions"].each do |session|
+        current_sessions["sessions"].each do |session|
           session_id = session["id"]
           say Text::Status::SESSION_TITLE % session_id
-          call_api(:get, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::TEST_EXECUTIONS}") do |api_response|
-            display_attributes(DisplayedAttributes::TEST_EXECUTION, api_response)
-          end
+          current_test_executions = call_api(:get, "#{Api::Path::SESSIONS}/#{session_id}/#{Api::Path::TEST_EXECUTIONS}")
+          display_attributes(DisplayedAttributes::TEST_EXECUTION, current_test_executions)
         end
       end
+    rescue TddiumClient::Error::Base
     end
   end
 
@@ -415,7 +406,7 @@ class Tddium < Thor
   end
 
   def tddium_client
-    @tddium_client ||= TddiumClient.new
+    @tddium_client ||= TddiumClient::Client.new
   end
 
   def tddium_file_name
@@ -439,9 +430,9 @@ class Tddium < Thor
     @tddium_settings
   end
 
-  def user_logged_in?(active = true, &block)
+  def user_logged_in?(active = true)
     result = tddium_settings(:fail_with_message => false) && tddium_settings["api_key"]
-    (result && active) ? get_user(&block).success? : result
+    (result && active) ? get_user : result
   end
 
   def write_api_key(api_key)
@@ -458,5 +449,4 @@ class Tddium < Thor
       file.write(tddium_settings.merge({"branches" => branches}).to_json)
     end
   end
-
 end

data/lib/tddium/version.rb

@@ -3,5 +3,5 @@ Copyright (c) 2011 Solano Labs All Rights Reserved
 =end
 
 module TddiumVersion
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/tddium_spec.rb

@@ -13,8 +13,6 @@ describe Tddium do
   SAMPLE_APP_NAME = "tddelicious"
   SAMPLE_BRANCH_NAME = "test"
   SAMPLE_BUNDLER_VERSION = "1.10.10"
-  SAMPLE_CALL_API_RESPONSE = [0, 200, nil]
-  SAMPLE_CALL_API_ERROR = [1, 501, "an error"]
   SAMPLE_DATE_TIME = "2011-03-11T08:43:02Z"
   SAMPLE_EMAIL = "someone@example.com"
   SAMPLE_INVITATION_TOKEN = "TZce3NueiXp2lMTmaeRr"
@@ -29,13 +27,14 @@ describe Tddium do
   SAMPLE_SUITE_ID = 1
   SAMPLE_SUITES_RESPONSE = {"suites" => [{"repo_name" => SAMPLE_APP_NAME, "branch" => SAMPLE_BRANCH_NAME, "id" => SAMPLE_SUITE_ID}]}
   SAMPLE_TDDIUM_CONFIG_FILE = ".tddium.test"
+  SAMPLE_TEST_EXECUTION_STATS = "total 1, notstarted 0, started 1, passed 0, failed 0, pending 0, error 0", "start_time"
   SAMPLE_TEST_PATTERN = "**/*_spec.rb"
   SAMPLE_USER_RESPONSE = {"user"=> {"api_key" => SAMPLE_API_KEY, "email" => SAMPLE_EMAIL, "created_at" => SAMPLE_DATE_TIME, "recurly_url" => SAMPLE_RECURLY_URL}}
 
   def call_api_should_receive(options = {})
     params = [options[:method] || anything, options[:path] || anything, options[:params] || anything, (options[:api_key] || options[:api_key] == false) ? options[:api_key] : anything]
-    tddium_client.stub(:call_api).with(*params)                       # To prevent the yield
-    tddium_client.should_receive(:call_api).with(*params).and_return(SAMPLE_CALL_API_ERROR)
+    tddium_client.stub(:call_api).with(*params).and_raise(TddiumClient::Error::Base)
+    tddium_client.should_receive(:call_api).with(*params)
   end
 
   def extract_options!(array, *option_keys)
@@ -64,14 +63,24 @@ describe Tddium do
   end
 
   def stub_call_api_response(method, path, *response)
-    options = extract_options!(response, :and_return, :and_yield)
-    options[:and_yield] = true unless options[:and_yield] == false
     result = tddium_client.stub(:call_api).with(method, path, anything, anything)
-    result = result.and_yield(response.first) if options[:and_yield]
-    result.and_return(options[:and_return] || SAMPLE_CALL_API_ERROR)
-    response.each_with_index do |current_response, index|
-      result = result.and_yield(current_response) unless index.zero? || !options[:and_yield]
+    response = [{}] if response.empty?
+    response_mocks = []
+    response.each do |current_response|
+      current_response["status"] ||= 0
+      status = current_response["status"]
+      if status == 0
+        tddium_client_result = mock(TddiumClient::Result::API)
+        response_mocks << tddium_client_result
+      else
+        tddium_client_result = mock(TddiumClient::Error::API, :body => current_response.to_json)
+        result.and_raise(TddiumClient::Error::API.new(tddium_client_result))
+      end
+      current_response.each do |k, v|
+        tddium_client_result.stub(:[]).with(k).and_return(v)
+      end
     end
+    result.and_return(*response_mocks) unless response_mocks.empty?
   end
 
   def stub_cli_options(tddium, options = {})
@@ -118,15 +127,14 @@ describe Tddium do
   end
 
   def stub_tddium_client
-    TddiumClient.stub(:new).and_return(tddium_client)
-    tddium_client.stub(:environment).and_return(:test)
-    tddium_client.stub(:call_api).and_return(SAMPLE_CALL_API_ERROR)
+    TddiumClient::Client.stub(:new).and_return(tddium_client)
+    tddium_client.stub(:environment).and_return("test")
+    tddium_client.stub(:call_api).and_raise(TddiumClient::Error::Base)
   end
 
   let(:tddium) { Tddium.new }
   let(:tddium_client) { mock(TddiumClient).as_null_object }
 
-
   shared_examples_for "a password prompt" do
     context "--password was not passed in" do
       it "should prompt for a password or confirmation" do
@@ -146,8 +154,8 @@ describe Tddium do
 
   shared_examples_for "an unsuccessful api call" do
     it "should show the error" do
-      tddium_client.stub(:call_api).and_return(SAMPLE_CALL_API_ERROR)
-      tddium.should_receive(:say).with(SAMPLE_CALL_API_ERROR[2])
+      tddium_client.stub(:call_api).and_raise(TddiumClient::Error::Base)
+      tddium.should_receive(:say).with(TddiumClient::Error::Base.new.message)
       run(tddium)
     end
   end
@@ -172,49 +180,6 @@ describe Tddium do
     end
   end
 
-  shared_examples_for "logging in a user" do
-    context "there is a tddium config file with an api key" do
-      before {stub_config_file(:api_key => "some api key")}
-
-      it "should send a 'GET' request to '#{Tddium::Api::Path::USERS}'" do
-        call_api_should_receive(:method => :get, :path => /#{Tddium::Api::Path::USERS}$/)
-        run(tddium)
-      end
-    end
-
-    context "the tddium config file is missing or corrupt or the api key is invalid" do
-      context "--email was not passed in" do
-        it "should prompt for the user's email address" do
-          tddium.should_receive(:ask).with(Tddium::Text::Prompt::EMAIL)
-          run(tddium)
-        end
-      end
-
-      context "--email was passed in" do
-        it "should not prompt for the user's email address" do
-          tddium.should_not_receive(:ask).with(Tddium::Text::Prompt::EMAIL)
-          run(tddium, :email => SAMPLE_EMAIL)
-        end
-      end
-
-      it_should_behave_like "a password prompt" do
-        let(:password_prompt) {Tddium::Text::Prompt::PASSWORD}
-      end
-
-      it "should try to sign in the user with their email & password" do
-        tddium.stub(:ask).with(Tddium::Text::Prompt::EMAIL).and_return(SAMPLE_EMAIL)
-        HighLine.stub(:ask).with(Tddium::Text::Prompt::PASSWORD).and_return(SAMPLE_PASSWORD)
-        call_api_should_receive(:method => :post, :path => /#{Tddium::Api::Path::SIGN_IN}$/, :params => {:user => {:email => SAMPLE_EMAIL, :password => SAMPLE_PASSWORD}}, :api_key => false)
-        run(tddium)
-      end
-    end
-
-    context "the user logs in successfully with their email and password" do
-      before{stub_call_api_response(:post, Tddium::Api::Path::SIGN_IN, {"api_key" => SAMPLE_API_KEY})}
-      it_should_behave_like "writing the api key to the .tddium file"
-    end
-  end
-
   shared_examples_for "sending the api key" do
     it "should call the api with the api key" do
       call_api_should_receive(:api_key => SAMPLE_API_KEY)
@@ -288,14 +253,37 @@ describe Tddium do
     end
   end
 
-  shared_examples_for "writing the api key to the .tddium file" do
-    it "should write the api key to the .tddium file" do
+  shared_examples_for "with the correct environment extension" do
+    it "should write the api key to the .tddium file with the relevent environment extension" do
       run(tddium)
-      tddium_file = File.open(SAMPLE_TDDIUM_CONFIG_FILE) { |file| file.read }
+      tddium_file = File.open(".tddium#{environment_extension}") { |file| file.read }
       JSON.parse(tddium_file)["api_key"].should == SAMPLE_API_KEY
     end
   end
 
+  shared_examples_for "writing the api key to the .tddium file" do
+    context "production environment" do
+      before { tddium_client.stub(:environment).and_return("production") }
+      it_should_behave_like "with the correct environment extension" do
+        let(:environment_extension) {""}
+      end
+    end
+
+    context "development environment" do
+      before { tddium_client.stub(:environment).and_return("development") }
+      it_should_behave_like "with the correct environment extension" do
+        let(:environment_extension) {".development"}
+      end
+    end
+
+    context "test environment" do
+      before { tddium_client.stub(:environment).and_return("test") }
+      it_should_behave_like "with the correct environment extension" do
+        let(:environment_extension) {".test"}
+      end
+    end
+  end
+
   describe "#account" do
     before do
       stub_defaults
@@ -402,7 +390,7 @@ describe Tddium do
             it_should_behave_like "an unsuccessful api call"
 
             context "because the invitation is invalid" do
-              before { stub_call_api_response(:post, Tddium::Api::Path::USERS, :and_yield => false, :and_return => [Tddium::Api::ErrorCode::INVALID_INVITATION, 409, "Invitation is invalid"]) }
+              before { stub_call_api_response(:post, Tddium::Api::Path::USERS, {"status" => Tddium::Api::ErrorCode::INVALID_INVITATION}) }
               it "should show the user: '#{Tddium::Text::Error::INVALID_INVITATION}'" do
                 tddium.should_receive(:say).with(Tddium::Text::Error::INVALID_INVITATION)
                 run_account(tddium)
@@ -422,12 +410,52 @@ describe Tddium do
     end
 
     it_should_behave_like "set the default environment"
-    it_should_behave_like "logging in a user"
+
+    context "there is a tddium config file with an api key" do
+      before {stub_config_file(:api_key => "some api key")}
+
+      it "should send a 'GET' request to '#{Tddium::Api::Path::USERS}'" do
+        call_api_should_receive(:method => :get, :path => /#{Tddium::Api::Path::USERS}$/)
+        run(tddium)
+      end
+    end
+
+    context "the tddium config file is missing or corrupt or the api key is invalid" do
+      context "--email was not passed in" do
+        it "should prompt for the user's email address" do
+          tddium.should_receive(:ask).with(Tddium::Text::Prompt::EMAIL)
+          run(tddium)
+        end
+      end
+
+      context "--email was passed in" do
+        it "should not prompt for the user's email address" do
+          tddium.should_not_receive(:ask).with(Tddium::Text::Prompt::EMAIL)
+          run(tddium, :email => SAMPLE_EMAIL)
+        end
+      end
+
+      it_should_behave_like "a password prompt" do
+        let(:password_prompt) {Tddium::Text::Prompt::PASSWORD}
+      end
+
+      it "should try to sign in the user with their email & password" do
+        tddium.stub(:ask).with(Tddium::Text::Prompt::EMAIL).and_return(SAMPLE_EMAIL)
+        HighLine.stub(:ask).with(Tddium::Text::Prompt::PASSWORD).and_return(SAMPLE_PASSWORD)
+        call_api_should_receive(:method => :post, :path => /#{Tddium::Api::Path::SIGN_IN}$/, :params => {:user => {:email => SAMPLE_EMAIL, :password => SAMPLE_PASSWORD}}, :api_key => false)
+        run(tddium)
+      end
+
+      context "the user logs in successfully with their email and password" do
+        before{stub_call_api_response(:post, Tddium::Api::Path::SIGN_IN, {"api_key" => SAMPLE_API_KEY})}
+        it_should_behave_like "writing the api key to the .tddium file"
+      end
+    end
 
     context "user is already logged in" do
       before do
         stub_config_file(:api_key => SAMPLE_API_KEY)
-        stub_call_api_response(:get, Tddium::Api::Path::USERS, :and_yield => false, :and_return => SAMPLE_CALL_API_RESPONSE)
+        stub_call_api_response(:get, Tddium::Api::Path::USERS)
       end
 
       it "should show the user: '#{Tddium::Text::Process::ALREADY_LOGGED_IN}'" do
@@ -437,7 +465,7 @@ describe Tddium do
     end
 
     context "the user logs in successfully" do
-      before{stub_call_api_response(:post, Tddium::Api::Path::SIGN_IN, {})}
+      before{ stub_call_api_response(:post, Tddium::Api::Path::SIGN_IN, {"api_key" => SAMPLE_API_KEY})}
       it "should show the user: '#{Tddium::Text::Process::LOGGED_IN_SUCCESSFULLY}'" do
         tddium.should_receive(:say).with(Tddium::Text::Process::LOGGED_IN_SUCCESSFULLY)
         run_login(tddium)
@@ -450,7 +478,7 @@ describe Tddium do
   end
 
   describe "#logout" do
-    before { tddium.stub(:say) }
+    before { stub_defaults }
 
     context ".tddium file exists" do
       before { stub_config_file }
@@ -554,9 +582,11 @@ describe Tddium do
 
           context "'POST #{Tddium::Api::Path::START_TEST_EXECUTIONS}' is successful" do
             let(:get_test_executions_response) { {"report"=>SAMPLE_REPORT_URL, "tests"=>{"spec/mouse_spec.rb"=>{"end_time"=>SAMPLE_DATE_TIME, "status"=>"pending"}, "spec/pig_spec.rb"=>{"end_time"=>nil, "status"=>"started"}, "spec/dog_spec.rb"=>{"end_time"=>SAMPLE_DATE_TIME, "status"=>"failed"}, "spec/cat_spec.rb"=>{"end_time"=>SAMPLE_DATE_TIME, "status"=>"passed"}}} }
-            before do
-              response = {"started"=>1, "status"=>0}
-              stub_call_api_response(:post, "#{Tddium::Api::Path::SESSIONS}/#{SAMPLE_SESSION_ID}/#{Tddium::Api::Path::START_TEST_EXECUTIONS}", response)
+            before {stub_call_api_response(:post, "#{Tddium::Api::Path::SESSIONS}/#{SAMPLE_SESSION_ID}/#{Tddium::Api::Path::START_TEST_EXECUTIONS}", {"started"=>1, "status"=>0, "report" => SAMPLE_REPORT_URL})}
+
+            it "should show the user: '#{Tddium::Text::Process::CHECK_TEST_REPORT % SAMPLE_REPORT_URL}'" do
+              tddium.should_receive(:say).with(Tddium::Text::Process::CHECK_TEST_REPORT % SAMPLE_REPORT_URL)
+              run_spec(tddium)
             end
 
             it "should tell the user to '#{Tddium::Text::Process::TERMINATE_INSTRUCTION}'" do
@@ -577,8 +607,8 @@ describe Tddium do
             it_should_behave_like "sending the api key"
 
             shared_examples_for("test output summary") do
-              it "should show the user a link to the report" do
-                tddium.should_receive(:say).with(Tddium::Text::Process::CHECK_TEST_REPORT % SAMPLE_REPORT_URL)
+              it "should put a new line before displaying the summary" do
+                tddium.should_receive(:say).with(" ")
                 run_spec(tddium)
               end
 
@@ -679,8 +709,13 @@ describe Tddium do
     it_should_behave_like ".tddium file is missing or corrupt"
     it_should_behave_like "suite has not been initialized"
 
+    it "should send a 'GET' request to '#{Tddium::Api::Path::SUITES}'" do
+      call_api_should_receive(:method => :get, :path => Tddium::Api::Path::SUITES)
+      run_status(tddium)
+    end
+
     context "'GET #{Tddium::Api::Path::SUITES}' is successful" do
-      context "returns no suites" do
+      context "but returns no suites" do
         before { stub_call_api_response(:get, Tddium::Api::Path::SUITES, {"suites" => []}) }
 
         it "should show the user '#{Tddium::Text::Status::NO_SUITE}'" do
@@ -689,11 +724,10 @@ describe Tddium do
         end
       end
 
-      context "returns some suites" do
+      context "and returns some suites" do
         let(:suite_attributes) { {"id"=>SAMPLE_SUITE_ID, "repo_name"=>SAMPLE_APP_NAME, "ruby_version"=>SAMPLE_RUBY_VERSION, "branch" => SAMPLE_BRANCH_NAME, "test_pattern" => SAMPLE_TEST_PATTERN, "bundler_version" => SAMPLE_BUNDLER_VERSION, "rubygems_version" => SAMPLE_RUBYGEMS_VERSION}}
         before do
-          suites_response = {"suites"=>[suite_attributes], "status"=>0}
-          stub_call_api_response(:get, Tddium::Api::Path::SUITES, suites_response)
+          stub_call_api_response(:get, Tddium::Api::Path::SUITES, {"suites"=>[suite_attributes]})
         end
 
         it "should show all suites" do
@@ -749,8 +783,7 @@ describe Tddium do
           context "show active sessions" do
             context "without any session" do
               before do
-                sessions_response = {"status"=>0, "sessions"=>[]}
-                stub_call_api_response(:get, Tddium::Api::Path::SESSIONS, sessions_response)
+                stub_call_api_response(:get, Tddium::Api::Path::SESSIONS, {"sessions"=>[]})
               end
 
               it "should display no active session message" do
@@ -762,26 +795,33 @@ describe Tddium do
             context "with some sessions" do
               let(:session_attributes) { {"id"=>SAMPLE_SESSION_ID, "user_id"=>3} }
               before do
-                sessions_response = {"status"=>0, "sessions"=>[session_attributes]}
-                stub_call_api_response(:get, Tddium::Api::Path::SESSIONS, sessions_response)
+                stub_call_api_response(:get, Tddium::Api::Path::SESSIONS, {"sessions"=>[session_attributes]})
               end
 
-              it "should display the active sessions prompt" do
+              it "should show the user: '#{Tddium::Text::Status::ACTIVE_SESSIONS}'" do
                 tddium.should_receive(:say).with(Tddium::Text::Status::ACTIVE_SESSIONS)
                 run_status(tddium)
               end
 
-              it_should_behave_like "attribute details" do
-                let(:attributes_to_display) {Tddium::DisplayedAttributes::TEST_EXECUTION}
-                let(:attributes_to_hide) { [/id/] }
-                let(:attributes) { session_attributes }
+              it "should send a 'GET' request to '#{Tddium::Api::Path::TEST_EXECUTIONS}'" do
+                call_api_should_receive(:method => :get, :path => /#{Tddium::Api::Path::TEST_EXECUTIONS}$/)
+                run_status(tddium)
+              end
+
+              context "'GET #{Tddium::Api::Path::TEST_EXECUTIONS}' is successful" do
+                let(:test_execution_attributes) { {"report" => SAMPLE_REPORT_URL, "test_execution_stats" => SAMPLE_TEST_EXECUTION_STATS, "start_time" => SAMPLE_DATE_TIME, "end_time" => SAMPLE_DATE_TIME} }
+                before { stub_call_api_response(:get, /#{Tddium::Api::Path::TEST_EXECUTIONS}$/, test_execution_attributes) }
+                it_should_behave_like "attribute details" do
+                  let(:attributes_to_display) {Tddium::DisplayedAttributes::TEST_EXECUTION}
+                  let(:attributes_to_hide) { [] }
+                  let(:attributes) { test_execution_attributes }
+                end
               end
             end
           end
         end
       end
     end
-
     it_should_behave_like "an unsuccessful api call"
   end
 
@@ -803,7 +843,7 @@ describe Tddium do
     context ".tddium file contains no suites" do
       before do
         stub_default_suite_name
-        stub_call_api_response(:get, Tddium::Api::Path::SUITES, {"suites" => []}, :and_return => SAMPLE_CALL_API_RESPONSE)
+        stub_call_api_response(:get, Tddium::Api::Path::SUITES, {"suites" => []})
       end
 
       context "using defaults" do
@@ -850,7 +890,7 @@ describe Tddium do
 
       context "but this user has already registered some suites" do
         before do
-          stub_call_api_response(:get, Tddium::Api::Path::SUITES, SAMPLE_SUITES_RESPONSE, {"suites" => []}, :and_return => SAMPLE_CALL_API_RESPONSE)
+          stub_call_api_response(:get, Tddium::Api::Path::SUITES, SAMPLE_SUITES_RESPONSE, {"suites" => []})
           tddium.stub(:ask).with(Tddium::Text::Prompt::USE_EXISTING_SUITE % SAMPLE_APP_NAME).and_return(Tddium::Text::Prompt::Response::YES)
         end
 
@@ -871,7 +911,7 @@ describe Tddium do
 
         context "passing --name=my_suite" do
           before do
-            stub_call_api_response(:get, Tddium::Api::Path::SUITES, SAMPLE_SUITES_RESPONSE, :and_return => SAMPLE_CALL_API_RESPONSE)
+            stub_call_api_response(:get, Tddium::Api::Path::SUITES, SAMPLE_SUITES_RESPONSE)
           end
 
           it "should not ask the user if they want to use the existing suite" do
@@ -890,7 +930,7 @@ describe Tddium do
 
         context "the user wants to use the existing suite" do
           before do
-            stub_call_api_response(:get, Tddium::Api::Path::SUITES, SAMPLE_SUITES_RESPONSE, :and_return => SAMPLE_CALL_API_RESPONSE)
+            stub_call_api_response(:get, Tddium::Api::Path::SUITES, SAMPLE_SUITES_RESPONSE)
           end
 
           it "should not send a 'POST' request to '#{Tddium::Api::Path::SUITES}'" do

data/tddium.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Jay Moorthi"]
   s.email       = ["info@tddium.com"]
   s.homepage    = "http://www.tddium.com/"
-  s.summary     = %q{tddium Cloud Test Runner}
-  s.description = %q{tddium gets your rspec+selenium tests into the cloud by running them on your VMs}
+  s.summary     = %q{tddium Hosted Testing}
+  s.description = %q{tddium runs your rspec (and Selenium) tests in the cloud, in parallel!}
 
   s.rubyforge_project = "tddium"
 
@@ -26,7 +26,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency("thor")
   s.add_runtime_dependency("highline")
   s.add_runtime_dependency("json")
-  s.add_runtime_dependency("tddium_client", "=0.0.3")
+  s.add_runtime_dependency("tddium_client", ">=0.0.6")
 
   s.add_development_dependency("rspec")
   s.add_development_dependency("fakefs")

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: tddium-preview
 version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: 
+  prerelease: false
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Jay Moorthi
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-31 00:00:00 -07:00
+date: 2011-04-04 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,7 +25,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -40,7 +38,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -54,7 +51,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -66,14 +62,13 @@ dependencies:
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 25
         segments: 
         - 0
         - 0
-        - 3
-        version: 0.0.3
+        - 6
+        version: 0.0.6
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
@@ -84,7 +79,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -98,7 +92,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -112,7 +105,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -126,13 +118,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
   type: :development
   version_requirements: *id008
-description: tddium gets your rspec+selenium tests into the cloud by running them on your VMs
+description: tddium runs your rspec (and Selenium) tests in the cloud, in parallel!
 email: 
 - info@tddium.com
 executables: 
@@ -171,7 +162,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -180,17 +170,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: tddium
-rubygems_version: 1.5.2
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: tddium Cloud Test Runner
+summary: tddium Hosted Testing
 test_files: 
 - spec/spec_helper.rb
 - spec/tddium_spec.rb