shelly 0.1.34 → 0.1.35

data/spec/shelly/cli/organization_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "shelly/cli/organization"
+
+describe Shelly::CLI::Organization do
+  before do
+  FileUtils.stub(:chmod)
+  @organization = Shelly::CLI::Organization.new
+  Shelly::CLI::Organization.stub(:new).and_return(@organization)
+  @client = mock
+  Shelly::Client.stub(:new).and_return(@client)
+  $stdout.stub(:puts)
+  $stdout.stub(:print)
+  @client.stub(:token).and_return("abc")
+  FileUtils.mkdir_p("/projects/foo")
+  Dir.chdir("/projects/foo")
+  end
+
+  describe "#list" do
+    before do
+      @client.stub(:token).and_return("abc")
+      @client.stub(:organizations).and_return([
+        {"name" => "aaa", "app_code_names" => ["app1"]},
+        {"name" => "ccc", "app_code_names" => ["app2", "app3"]}
+      ])
+      @client.stub(:app).with("app1").and_return("state" => "running")
+      @client.stub(:app).with("app2").and_return("state" => "turned_off")
+      @client.stub(:app).with("app3").and_return("state" => "no_code")
+    end
+
+    it "should ensure user has logged in" do
+      hooks(@organization, :list).should include(:logged_in?)
+    end
+
+    it "should print out all organizations with apps" do
+      $stdout.should_receive(:puts).with(green("You have access to the following organizations and clouds:"))
+      $stdout.should_receive(:puts).with(green("aaa"))
+      $stdout.should_receive(:puts).with(/app1 \s+ |  running/)
+      $stdout.should_receive(:puts).with(green("ccc"))
+      $stdout.should_receive(:puts).with(/app2 \s+ |  turned off/)
+      $stdout.should_receive(:puts).with(/app3 \s+ |  no code/)
+      invoke(@organization, :list)
+    end
+  end
+end

data/spec/shelly/cli/user_spec.rb

@@ -1,5 +1,6 @@
 require "spec_helper"
 require "shelly/cli/user"
+require "shelly/cli/organization"
 
 describe Shelly::CLI::User do
   before do
@@ -15,40 +16,45 @@ describe Shelly::CLI::User do
     Dir.chdir("/projects/foo")
     @app = Shelly::App.new("foo-staging")
     File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\n") }
+
+    @client.stub(:members).and_return({})
   end
 
   describe "#help" do
     it "should show help" do
       $stdout.should_receive(:puts).with("Tasks:")
-      $stdout.should_receive(:puts).with(/add \[EMAIL\]\s+# Add new developer to clouds defined in Cloudfile/)
-        $stdout.should_receive(:puts).with(/list\s+# List users with access to clouds defined in Cloudfile/)
+      $stdout.should_receive(:puts).with(/add \[EMAIL\]\s+# Add new developer to organization/)
+      $stdout.should_receive(:puts).with(/list\s+# List users with access to organizations/)
+      $stdout.should_receive(:puts).with(/delete \[EMAIL\]\s+# Remove developer from organization/)
       invoke(@cli_user, :help)
     end
   end
 
   describe "#list" do
+    let(:organizations){
+      [{"name" => "org1"}]
+    }
+
     let(:response) {
-      [{'email' => 'user@example.com', 'active' => true},
-       {'email' => 'auser2@example2.com', 'active' => false}]
+      [{'email' => 'user@example.com', 'active' => true, "owner" => true},
+       {'email' => 'user2@example2.com', 'active' => true, "owner" => false},
+       {'email' => 'user3@example3.com', 'active' => false, "owner" => true}]
     }
 
     it "should ensure user has logged in" do
       hooks(@cli_user, :list).should include(:logged_in?)
     end
 
-    # multiple_clouds is tested in main_spec.rb in describe "#start" block
-    it "should ensure multiple_clouds check" do
-      @client.stub(:collaborations).and_return(response)
-      @cli_user.should_receive(:multiple_clouds).and_return(@app)
-      invoke(@cli_user, :list)
-    end
-
     context "on success" do
-      it "should display clouds and users" do
-        @client.stub(:collaborations).and_return(response)
-        $stdout.should_receive(:puts).with("Cloud foo-staging:")
-        $stdout.should_receive(:puts).with("  user@example.com")
-        $stdout.should_receive(:puts).with("  auser2@example2.com (invited)")
+      it "should display organization's users" do
+        @cli_user.options = {:organization => "foo-org"}
+        @client.stub(:organizations).and_return(organizations)
+        @client.stub(:members).and_return(response)
+        $stdout.should_receive(:puts).with("Organizations with users:")
+        $stdout.should_receive(:puts).with(green "  org1")
+        $stdout.should_receive(:puts).with(/user@example.com\s+ \| owner/)
+        $stdout.should_receive(:puts).with(/user2@example2.com\s+ \| member/)
+        $stdout.should_receive(:puts).with(/user3@example3.com \(invited\)\s+ \| owner/)
         invoke(@cli_user, :list)
       end
     end
@@ -56,78 +62,108 @@ describe Shelly::CLI::User do
 
   describe "#add" do
     before do
-      @user = Shelly::User.new
-      @client.stub(:apps).and_return([{"code_name" => "abc"}, {"code_name" => "fooo"}])
-      Shelly::User.stub(:new).and_return(@user)
+      @organization = Shelly::Organization.new("name" => "foo-org")
+      Shelly::Organization.stub(:new).and_return(@organization)
+      @cli_user.options = {:organization => "foo-org"}
     end
 
     it "should ensure user has logged in" do
       hooks(@cli_user, :add).should include(:logged_in?)
     end
 
-
     context "on success" do
       before do
-        @client.should_receive(:send_invitation).with("foo-staging", "megan@example.com")
-      end
-
-      # multiple_clouds is tested in main_spec.rb in describe "#start" block
-      it "should ensure multiple_clouds check" do
-        @cli_user.should_receive(:multiple_clouds).and_return(@app)
-        invoke(@cli_user, :add, "megan@example.com")
+        @client.should_receive(:send_invitation).with("foo-org", "megan@example.com", true)
       end
 
       it "should ask about email" do
-        fake_stdin(["megan@example.com"]) do
+        $stdout.should_receive(:puts).with(green "Sending invitation to megan@example.com to work on foo-org organization")
+        fake_stdin(["megan@example.com", "yes"]) do
           invoke(@cli_user, :add)
         end
       end
 
-      it "should receive clouds from the Cloudfile" do
-        invoke(@cli_user, :add, "megan@example.com")
+      it "should use email from argument" do
+        $stdout.should_receive(:puts).with(green "Sending invitation to megan@example.com to work on foo-org organization")
+        fake_stdin(["yes"]) do
+          invoke(@cli_user, :add, "megan@example.com")
+        end
+      end
+    end
+
+    context "on failure" do
+      it "should list all user's organizations" do
+        @cli_user.options = {}
+        $stdout.should_receive(:puts).with(red "You have to specify organization")
+        $stdout.should_receive(:puts).with("Select organization using `shelly user add [EMAIL] --organization ORGANIZATION_NAME`")
+        Shelly::CLI::Organization.stub_chain(:new, :list)
+        lambda do
+          invoke(@cli_user, :add, "megan@example.com")
+        end.should raise_error(SystemExit)
+      end
+
+      it "should display forbidden exception" do
+        exception = Shelly::Client::ForbiddenException.new({})
+        @client.stub(:send_invitation).and_raise(exception)
+        $stdout.should_receive(:puts).with(red "You have to be organization's owner to add new members")
+
+        lambda do
+          fake_stdin(["yes"]) { invoke(@cli_user, :add, "megan@example.com") }
+        end.should raise_error(SystemExit)
+      end
+
+      it "should display not found" do
+        response = {"resource" => "organization"}
+        exception = Shelly::Client::NotFoundException.new(response)
+        @client.stub(:send_invitation).and_raise(exception)
+
+        $stdout.should_receive(:puts).with(red "Organization 'foo-org' not found")
+        $stdout.should_receive(:puts).with(red "You can list organizations you have access to with `shelly organization list`")
+        lambda do
+          fake_stdin(["yes"]) { invoke(@cli_user, :add, "megan@example.com") }
+        end.should raise_error(SystemExit)
       end
 
-      it "should receive clouds from the Cloudfile" do
-        $stdout.should_receive(:puts).with("\e[32mSending invitation to megan@example.com to work on foo-staging\e[0m")
-        invoke(@cli_user, :add, "megan@example.com")
+      it "should display validation exception" do
+        body = {"message" => "Validation Failed", "errors" => [["email", "megan@example.com has been already taken"]]}
+        exception = Shelly::Client::ValidationException.new(body)
+        @client.stub(:send_invitation).and_raise(exception)
+        $stdout.should_receive(:puts).with(red "User megan@example.com is already in the organization foo-org")
+
+        lambda do
+          fake_stdin(["yes"]) { invoke(@cli_user, :add, "megan@example.com") }
+        end.should raise_error(SystemExit)
       end
     end
   end
 
   describe "#delete" do
     before do
-      @user = Shelly::User.new
-      @client.stub(:apps).and_return([{"code_name" => "abc"}, {"code_name" => "fooo"}])
-      Shelly::User.stub(:new).and_return(@user)
+      @organization = Shelly::Organization.new("name" => "foo-org")
+      Shelly::Organization.stub(:new).and_return(@organization)
+      @cli_user.options = {:organization => "foo-org"}
     end
 
     it "should ensure user has logged in" do
       hooks(@cli_user, :delete).should include(:logged_in?)
     end
 
-    # multiple_clouds is tested in main_spec.rb in describe "#start" block
-    it "should ensure multiple_clouds check" do
-      @client.should_receive(:delete_collaboration).with("foo-staging", "megan@example.com")
-      @cli_user.should_receive(:multiple_clouds).and_return(@app)
-      invoke(@cli_user, :delete, "megan@example.com")
-    end
-
     context "on success" do
       it "should ask about email" do
-        @client.should_receive(:delete_collaboration).with("foo-staging", "megan@example.com")
+        @client.should_receive(:delete_member).with("foo-org", "megan@example.com")
         fake_stdin(["megan@example.com"]) do
           invoke(@cli_user, :delete)
         end
       end
 
       it "should receive email from param" do
-        @client.should_receive(:delete_collaboration).with("foo-staging", "megan@example.com")
+        @client.should_receive(:delete_member).with("foo-org", "megan@example.com")
         invoke(@cli_user, :delete, "megan@example.com")
       end
 
       it "should show that user was removed" do
-        @client.stub(:delete_collaboration)
-        $stdout.should_receive(:puts).with("User megan@example.com deleted from cloud foo-staging")
+        @client.stub(:delete_member)
+        $stdout.should_receive(:puts).with("User megan@example.com deleted from organization foo-org")
         invoke(@cli_user, :delete, "megan@example.com")
       end
     end
@@ -135,7 +171,7 @@ describe Shelly::CLI::User do
     context "on failure" do
       it "should show that user wasn't found" do
         exception = Shelly::Client::NotFoundException.new("resource" => "user")
-        @client.stub(:delete_collaboration).and_raise(exception)
+        @client.stub(:delete_member).and_raise(exception)
         $stdout.should_receive(:puts).with(red "User 'megan@example.com' not found")
         $stdout.should_receive(:puts).with(red "You can list users with `shelly user list`")
         lambda {
@@ -143,15 +179,35 @@ describe Shelly::CLI::User do
         }.should raise_error(SystemExit)
       end
 
+      it "should show that organization wasn't found" do
+        exception = Shelly::Client::NotFoundException.new("resource" => "organization")
+        @client.stub(:delete_member).and_raise(exception)
+        $stdout.should_receive(:puts).with(red "Organization 'foo-org' not found")
+        $stdout.should_receive(:puts).with(red "You can list organizations you have access to with `shelly organization list`")
+        lambda {
+          invoke(@cli_user, :delete, "megan@example.com")
+        }.should raise_error(SystemExit)
+      end
+
       it "should show that user can't delete own collaboration" do
         exception = Shelly::Client::ConflictException.new("message" =>
           "Can't remove own collaboration")
-        @client.stub(:delete_collaboration).and_raise(exception)
+        @client.stub(:delete_member).and_raise(exception)
         $stdout.should_receive(:puts).with(red "Can't remove own collaboration")
         lambda {
           invoke(@cli_user, :delete, "megan@example.com")
         }.should raise_error(SystemExit)
       end
+
+      it "should show forbidden exception" do
+        exception = Shelly::Client::ForbiddenException.new({})
+        @client.stub(:delete_member).and_raise(exception)
+        $stdout.should_receive(:puts).with(red "You have to be organization's owner to remove members")
+
+        lambda {
+          invoke(@cli_user, :delete, "megan@example.com")
+        }.should raise_error(SystemExit)
+      end
     end
   end
 end

data/spec/shelly/client_spec.rb

@@ -165,17 +165,43 @@ describe Shelly::Client do
 
   describe "#create_app" do
     it "should send post with app's attributes" do
-      @client.should_receive(:post).with("/apps", :app => {:code_name => "foo", :ruby_version => "1.9.2"})
+      @client.should_receive(:post).with("/apps", :app => {:code_name => "foo", :ruby_version => "1.9.2"}, :organization_name => nil)
       @client.create_app(:code_name => "foo", :ruby_version => "1.9.2")
     end
+
+    it "should send post with app's attributes and organization name" do
+      @client.should_receive(:post).with("/apps", :app => {:code_name => "foo", :ruby_version => "1.9.2"}, :organization_name => "foo")
+      @client.create_app(:code_name => "foo", :ruby_version => "1.9.2", :organization_name => "foo")
+    end
+
+  end
+
+  describe "#organizations" do
+    it "should fetch organizations from API" do
+      FakeWeb.register_uri(:get, api_url("organizations"),
+       :body => [{:name => "org1", :app_code_names => ["app1"]},
+                 {:name => "org2", :app_code_names => ["app2"]}].to_json)
+      response = @client.organizations
+      response.should == [{"name" => "org1", "app_code_names" => ["app1"]},
+                          {"name" => "org2", "app_code_names" => ["app2"]}]
+    end
+  end
+
+  describe "#organization" do
+    it "should fetch organization from API" do
+      FakeWeb.register_uri(:get, api_url("organizations/foo-org"),
+        :body => {:name => "org1", :app_code_names => ["app1"]}.to_json)
+      response = @client.organization("foo-org")
+      response.should == {"name" => "org1", "app_code_names" => ["app1"]}
+    end
   end
 
-  describe "#collaborations" do
+  describe "#members" do
     it "should send get request with app code_names" do
-      FakeWeb.register_uri(:get, api_url("apps/staging-foo/collaborations"),
+      FakeWeb.register_uri(:get, api_url("organizations/staging-foo/memberships"),
         :body => [{:email => "test@example.com", :active => true},
                   {:email => "test2@example.com", :active => false}].to_json)
-      response = @client.collaborations("staging-foo")
+      response = @client.members("staging-foo")
       response.should == [{"email" => "test@example.com", 'active' => true},
                           {"email" => "test2@example.com", 'active' => false}]
     end
@@ -229,7 +255,7 @@ describe Shelly::Client do
 
   describe "#send_invitation" do
     it "should send post with developer's email" do
-      FakeWeb.register_uri(:post, api_url("apps/staging-foo/collaborations"), :body => {}.to_json)
+      FakeWeb.register_uri(:post, api_url("organizations/staging-foo/memberships"), :body => {}.to_json)
       response = @client.send_invitation("staging-foo", "megan@example.com")
       response.should == {}
     end
@@ -237,8 +263,8 @@ describe Shelly::Client do
 
   describe "#delete_collaboration" do
     it "should send delete with developer's email in url" do
-      FakeWeb.register_uri(:delete, api_url("apps/staging-foo/collaborations/megan@example.com"), :body => {}.to_json)
-      @client.delete_collaboration("staging-foo", "megan@example.com")
+      FakeWeb.register_uri(:delete, api_url("organizations/staging-foo/memberships/megan@example.com"), :body => {}.to_json)
+      @client.delete_member("staging-foo", "megan@example.com")
     end
   end
 

data/spec/shelly/organization_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+require "shelly/organization"
+
+describe Shelly::Organization do
+  before do
+    @client = mock
+    Shelly::Client.stub(:new).and_return(@client)
+    @organization = Shelly::Organization.new({"name" => "foo-org",
+      "app_code_names" => ['foo-staging']})
+  end
+
+  describe "#apps" do
+    it "should initialize App objects" do
+      Shelly::App.should_receive(:new).with('foo-staging')
+      @organization.apps
+    end
+  end
+
+  describe "#memberships" do
+    before do
+      response = [{"email" => "bb@example.com", "active" => true, "owner" => true},
+                  {"email" => "aa@example.com", "active" => true, "owner" => false},
+                  {"email" => "cc@example.com", "active" => false, "owner" => true},
+                  {"email" => "dd@example.com", "active" => false, "owner" => false}]
+      @client.stub(:members).with("foo-org").and_return(response)
+    end
+
+    it "should fetch organization's users" do
+      @client.should_receive(:members).with("foo-org")
+      @organization.memberships
+    end
+
+    it "should sort members by email" do
+      members = @organization.memberships
+      members.should == [{"email"=>"aa@example.com", "active"=>true, "owner"=>false},
+                         {"email"=>"bb@example.com", "active"=>true, "owner"=>true},
+                         {"email"=>"cc@example.com", "active"=>false, "owner"=>true},
+                         {"email"=>"dd@example.com", "active"=>false, "owner"=>false}]
+    end
+
+
+    context "owners" do
+      it "should return only owners without inactive members" do
+        owners = @organization.owners
+        owners.should == [{"email"=>"bb@example.com", "active"=>true, "owner"=>true}]
+      end
+    end
+
+    context "members" do
+      it "should return only members without inactive members" do
+        members = @organization.members
+        members.should == [{"email"=>"aa@example.com", "active"=>true, "owner"=>false}]
+      end
+    end
+
+    context "inactive_members" do
+      it "should return only inactive members" do
+        inactive = @organization.inactive_members
+        inactive.should == [{"email"=>"cc@example.com", "active"=>false, "owner"=>true},
+                           {"email"=>"dd@example.com", "active"=>false, "owner"=>false}]
+      end
+    end
+  end
+
+  describe "#send_invitation" do
+    it "should send invitation" do
+      @client.should_receive(:send_invitation).with("foo-org", "megan@example.com", true)
+      @organization.send_invitation("megan@example.com", true)
+    end
+  end
+
+  describe "#delete_member" do
+    it "should delete collaboration" do
+      @client.should_receive(:delete_member).with("foo-org", "megan@example.com")
+      @organization.delete_member("megan@example.com")
+    end
+  end
+end

data/spec/shelly/user_spec.rb

@@ -104,20 +104,6 @@ describe Shelly::User do
     end
   end
 
-  describe "#send_invitation" do
-    it "should send invitation" do
-      @client.should_receive(:send_invitation).with("foo-staging", "megan@example.com")
-      @user.send_invitation("foo-staging", "megan@example.com")
-    end
-  end
-
-  describe "#delete_collaboration" do
-    it "should delete collaboration" do
-      @client.should_receive(:delete_collaboration).with("foo-staging", "megan@example.com")
-      @user.delete_collaboration("foo-staging", "megan@example.com")
-    end
-  end
-
   describe "#ssh_key_path" do
     it "should return path to public dsa key file in the first place" do
       @user.ssh_key_path.should == File.expand_path("~/.ssh/id_dsa.pub")
@@ -195,5 +181,13 @@ describe Shelly::User do
       @user.apps
     end
   end
-end
 
+  describe "#organizations" do
+    it "should initialaize organizations objects" do
+      organizations = [{"name" => "org1"}]
+      @client.should_receive(:organizations).and_return(organizations)
+      Shelly::Organization.should_receive(:new).with({"name" => "org1"})
+      @user.organizations
+    end
+  end
+end