gooddata 0.6.11 → 0.6.12

data/spec/unit/models/project_blueprint_spec.rb

@@ -64,7 +64,6 @@ describe GoodData::Model::ProjectBlueprint do
       d.add_attribute("id", :title => "My Id")
       d.add_fact("amount", :title => "Amount")
     end
-
     bp1 = GoodData::Model::ProjectBlueprint.new(builder)
     bp1.valid?.should == true
 
@@ -90,7 +89,7 @@ describe GoodData::Model::ProjectBlueprint do
   end
 
   it 'should be able to tell me if ceratain dataset by name is in the blueprint' do
-    @blueprint.dataset?('devs').should be_true
+    @blueprint.dataset?('devs').should be_truthy
   end
 
   it 'should tell you it has anchor when it does' do
@@ -237,8 +236,4 @@ describe GoodData::Model::ProjectBlueprint do
     merged1 = @blueprint.merge(dataset)
     merged2 = dataset.merge(@blueprint)
   end
-
-  it "should generate manifest" do
-    m = GoodData::Model::ToManifest.to_manifest(@blueprint.to_hash)
-  end
 end

data/spec/unit/models/project_spec.rb

@@ -1,65 +1,39 @@
 # encoding: UTF-8
 
 require 'pmap'
-
 require 'gooddata'
 
-describe GoodData::Project do
-  before(:each) do
+describe GoodData::Project, :constraint => 'slow' do
+  before(:all) do
     @client = ConnectionHelper::create_default_connection
+    @project = ProjectHelper.get_default_project(:client => @client)
+    @domain = @client.domain(ConnectionHelper::DEFAULT_DOMAIN)
   end
 
-  after(:each) do
+  after(:all) do
     @client.disconnect
   end
 
-  def load_users_from_csv
-    GoodData::Helpers::Csv.read(:path => CsvHelper::CSV_PATH_IMPORT, :header => true) do |row|
-      json = {
-        'user' => {
-          'content' => {
-            'email' => row[2],
-            'login' => row[2],
-            'firstname' => row[0],
-            'lastname' => row[1],
-
-            # Following lines are ugly hack
-            'role' => row[6],
-            'password' => CryptoHelper.generate_password,
-            'domain' => row[9],
-
-            # And following lines are even much more ugly hack
-            # 'sso_provider' => '',
-            # 'authentication_modes' => ['sso', 'password']
-          },
-          'meta' => {}
-        }
-      }
-
-      GoodData::Membership.new(json)
-    end
-  end
-
-  describe '#[]' do
-    it 'Accepts :all parameter' do
-      projects = GoodData::Project[:all, :client => @client]
-      projects.should_not be_nil
-      projects.should be_a_kind_of(Array)
+  describe 'projects' do
+    it 'Can get all projects' do
+      projects = @client.projects
+      expect(projects).to_not be_nil
+      expect(projects).to be_a_kind_of(Array)
       projects.pmap do |project|
         expect(project).to be_an_instance_of(GoodData::Project)
       end
     end
 
     it 'Returns project if ID passed' do
-      project = GoodData::Project[ProjectHelper::PROJECT_ID, :client => @client]
-      project.should_not be_nil
-      project.should be_a_kind_of(GoodData::Project)
+      expect(@project).to_not be_nil
+      expect(@project).to be_a_kind_of(GoodData::Project)
+      expect(@project.pid).to eq @project.pid
     end
 
     it 'Returns project if URL passed' do
-      project = GoodData::Project[ProjectHelper::PROJECT_URL, :client => @client]
-      project.should_not be_nil
-      project.should be_a_kind_of(GoodData::Project)
+      expect(@project).to_not be_nil
+      expect(@project).to be_a_kind_of(GoodData::Project)
+      expect(@project.pid).to eq @project.pid
     end
 
     it 'Throws an exception when invalid format of URL passed' do
@@ -71,120 +45,123 @@ describe GoodData::Project do
   describe '#all' do
     it 'Returns all projects' do
       projects = GoodData::Project.all(:client => @client)
-      projects.should_not be_nil
-      projects.should be_a_kind_of(Array)
+      expect(projects).to_not be_nil
+      expect(projects).to be_a_kind_of(Array)
     end
   end
 
   describe '#get_role_by_identifier' do
     it 'Looks up for role by identifier' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      role = project.get_role_by_identifier('readOnlyUserRole')
-      role.should_not be_nil
-      role.should be_a_kind_of(GoodData::ProjectRole)
+      role = @project.get_role_by_identifier('readOnlyUserRole')
+      expect(role).to_not be_nil
+      expect(role).to be_a_kind_of(GoodData::ProjectRole)
     end
   end
 
   describe '#get_role_by_summary' do
     it 'Looks up for role by summary' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      role = project.get_role_by_summary('read only user role')
-      role.should_not be_nil
-      role.should be_a_kind_of(GoodData::ProjectRole)
+      role = @project.get_role_by_summary('read only user role')
+      expect(role).to_not be_nil
+      expect(role).to be_a_kind_of(GoodData::ProjectRole)
     end
   end
 
   describe '#get_role_by_title' do
     it 'Looks up for role by title' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      role = project.get_role_by_title('Viewer')
-      role.should_not be_nil
-      role.should be_a_kind_of(GoodData::ProjectRole)
+      role = @project.get_role_by_title('Viewer')
+      expect(role).to_not be_nil
+      expect(role).to be_a_kind_of(GoodData::ProjectRole)
     end
   end
 
   describe "#member" do
-    it 'Returns GoodData::Membership when looking for existing user using email' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      res = project.member('svarovsky+gem_tester@gooddata.com')
+    it 'Returns GoodData::Membership when looking for existing user using login' do
+      res = @project.get_user('svarovsky+gem_tester@gooddata.com')
       expect(res).to be_instance_of(GoodData::Membership)
     end
 
     it 'Returns GoodData::Membership when looking for existing user using URL' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      res = project.member(ConnectionHelper::DEFAULT_USER_URL)
+      res = @project.get_user(ConnectionHelper::DEFAULT_USER_URL)
       expect(res).to be_instance_of(GoodData::Membership)
     end
 
     it 'Returns GoodData::Membership when looking for existing user using GoodData::Profile' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      user = project.members.first
-      res = project.member(user)
+      user = @project.members.first
+      res = @project.get_user(user)
       expect(res).to be_instance_of(GoodData::Membership)
     end
 
     it 'Returns null for non-existing user' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      res = project.member('jan.kokotko@gooddata.com')
-      res.should be_nil
+      res = @project.get_user('john.doe@gooddata.com')
+      expect(res).to be_nil
     end
   end
 
   describe "#member?" do
-    it 'Returns true when looking for existing user using email' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      res = project.member?('svarovsky+gem_tester@gooddata.com')
-      res.should be_true
+    it 'Returns true when looking for existing user using login' do
+      res = @project.member?('svarovsky+gem_tester@gooddata.com')
+      expect(res).to be_truthy
     end
 
     it 'Returns true when looking for existing user using URL' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      res = project.member?(ConnectionHelper::DEFAULT_USER_URL)
-      res.should be_true
+      res = @project.member?(ConnectionHelper::DEFAULT_USER_URL)
+      expect(res).to be_truthy
     end
 
     it 'Returns true when looking for existing user using GoodData::Profile' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      user = project.members.first
-      res = project.member?(user)
-      res.should be_true
+      user = @project.members.first
+      res = @project.member?(user)
+      expect(res).to be_truthy
     end
 
     it 'Returns false for non-existing user' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      res = project.member?('jan.kokotko@gooddata.com')
-      res.should be_false
+      res = @project.member?('john.doe@gooddata.com')
+      expect(res).to be_falsey
     end
 
     it 'Returns true for existing user when using optional list' do
-      project = ProjectHelper.get_default_project(:client => @client)
-      list = project.members
-      res = project.member?('svarovsky+gem_tester@gooddata.com', list)
-      res.should be_true
+      list = @project.members
+      res = @project.member?('svarovsky+gem_tester@gooddata.com', list)
+      expect(res).to be_truthy
     end
 
     it 'Returns false for non-existing user when using optional list' do
-      project = ProjectHelper.get_default_project(:client => @client)
       list = []
-      res = project.member?('svarovsky+gem_tester@gooddata.com', list)
-      res.should be_false
+      res = @project.member?('svarovsky+gem_tester@gooddata.com', list)
+      expect(res).to be_falsey
     end
   end
 
-  describe '#processes' do
-    it 'Returns the processes' do
+  describe '#members?' do
+    it 'Returns array of bools when looking for existing users using GoodData::Profile' do
+      users = @project.members.take(10)
+      res = @project.members?(users)
+      expect(res.all?).to be_truthy
+    end
 
-      project = GoodData::Project[ProjectHelper::PROJECT_ID, {:client => @client}]
-      processes = project.processes
-      expect(processes).to be_a_kind_of(Array)
+    it 'Support variety of inputs' do
+      users = @project.members.take(1)
+      res = @project.members?(users + ['john.doe@gooddata.com'])
+      expect(res).to eq [true, false]
     end
   end
 
+  # describe '#processes' do
+  #   it 'Returns the processes' do
+  #     @project.deploy_process('./spec/data/ruby_process',
+  #                                   type: 'RUBY',
+  #                                   name: 'Test ETL Process')
+  #     processes = @project.processes
+  #     expect(processes).to be_a_kind_of(Array)
+  #     binding.pry
+  #     expect(processes.count).to eq 1
+  #     expect(processes.map(&:project).uniq).to eq [@project]
+  #   end
+  # end
+
   describe '#roles' do
     it 'Returns array of GoodData::ProjectRole' do
-      pending 'Investigate why is this soo slooow'
-      project = ProjectHelper.get_default_project(:client => @client)
-      roles = project.roles
+      roles = @project.roles
       expect(roles).to be_instance_of(Array)
 
       roles.each do |role|
@@ -193,193 +170,261 @@ describe GoodData::Project do
     end
   end
 
-  describe '#users' do
-    it 'Returns array of GoodData::Users' do
-      pending 'Investigate why is this soo slooow'
-
-      project = GoodData::Project[ProjectHelper::PROJECT_ID, {:client => @client}]
-
-      invitations = project.invitations
-      invitations.should_not be_nil
-      expect(invitations).to be_instance_of(Array)
-
-      users = project.users
-      expect(users).to be_instance_of(Array)
-
-      users.each do |user|
-        expect(user).to be_instance_of(GoodData::Membership)
-
-        roles = user.roles
-        roles.should_not be_nil
-        expect(roles).to be_instance_of(Array)
-
-        roles.each do |role|
-          expect(role).to be_instance_of(GoodData::ProjectRole)
-        end
-
-        permissions = user.permissions
-        permissions.should_not be_nil
-        permissions.should_not be_nil
-        expect(permissions).to be_instance_of(Hash)
-
-        # invitations = user.invitations
-        # invitations.should_not be_nil
-
-        if (user.email == 'tomas.korcak@gooddata.com')
-          projects = user.projects
-          projects.should_not be_nil
-          expect(projects).to be_instance_of(Array)
-
-          projects.each do |project|
-            expect(project).to be_instance_of(GoodData::Project)
-          end
-        end
-      end
-    end
-  end
-
-  describe '#users_create' do
-    it 'Creates new users' do
-      project = ProjectHelper.get_default_project(:client => @client)
-
-      users = (0...10).map do |i|
-        num = rand(1e6)
-        login = "gemtest#{num}@gooddata.com"
-
-        json = {
-          'user' => {
-            'content' => {
-              'email' => login,
-              'login' => login,
-              'firstname' => 'the',
-              'lastname' => num.to_s,
-
-              # Following lines are ugly hack
-              'role' => 'admin',
-              'password' => CryptoHelper.generate_password,
-              'domain' => ConnectionHelper::DEFAULT_DOMAIN,
-
-              # And following lines are even much more ugly hack
-              # 'sso_provider' => '',
-              # 'authentication_modes' => ['sso', 'password']
-            },
-            'meta' => {}
-          }
-        }
-
-        GoodData::Membership.new(json)
-      end
-
-      project = GoodData::Project[ProjectHelper::PROJECT_ID, {:client => @client}]
-      res = GoodData::Domain.users_create(users, nil, {:client => @client, :project => project})
-
-      project.users_create(users)
-
-      expect(res).to be_an_instance_of(Array)
-      res.each do |r|
-        expect(r).to be_an_instance_of(GoodData::Profile)
-        r.delete
-      end
-    end
-  end
-
-  describe '#users_import' do
-    it 'Import users from CSV' do
-
-      project = GoodData::Project[ProjectHelper::PROJECT_ID, {:client => @client}]
-
-      new_users = load_users_from_csv
-
-      project.users_import(new_users)
-    end
-  end
-
-  describe '#set_user_roles' do
-    it 'Properly updates user roles as needed' do
-      project = ProjectHelper.get_default_project(:client => @client)
-
-      project.set_user_roles(ConnectionHelper::DEFAULT_USERNAME, 'admin')
-    end
-  end
-
-  describe '#set_users_roles' do
-    it 'Properly updates user roles as needed for bunch of users' do
-      project = ProjectHelper.get_default_project(:client => @client)
-
-      list = load_users_from_csv
-
-      # Create domain users
-      domain_users = GoodData::Domain.users_create(list, ConnectionHelper::DEFAULT_DOMAIN, :client => @client, :project => project)
-      expect(domain_users.length).to equal(list.length)
-
-      # Create list with user, desired_roles hashes
-      domain_users.each_with_index do |user, index|
-        list[index] = {
-          :user => user,
-          :roles => list[index].json['user']['content']['role'].split(' ').map { |r| r.downcase }.sort
-        }
-      end
-
-      begin
-        res = project.set_users_roles(list)
-      rescue Exception => e
-        puts e.inspect
-      end
-
-      expect(res.length).to equal(list.length)
-      res.each do |update_result|
-        expect(update_result[:result]['projectUsersUpdateResult']['successful'][0]).to include(update_result[:user].uri)
-      end
-
-      domain_users.each do |user|
-        user.delete if user.email != ConnectionHelper::DEFAULT_USERNAME
-      end
-    end
-
-    it 'Properly updates user roles when user specified by email and :roles specified as array of string with role names' do
-      project = ProjectHelper.get_default_project(:client => @client)
-
-      list = [
-        {
-          :user => ConnectionHelper::DEFAULT_USERNAME,
-          :roles => ['admin']
-        }
-      ]
-
-      res = project.set_users_roles(list)
-      expect(res.length).to equal(list.length)
-    end
-
-    it 'Properly updates user roles when user specified by email and :roles specified as string with role name' do
-      project = ProjectHelper.get_default_project(:client => @client)
-
-      list = [
-        {
-          :user => ConnectionHelper::DEFAULT_USERNAME,
-          :roles => 'admin'
-        }
-      ]
-
-      res = project.set_users_roles(list)
-      expect(res.length).to equal(list.length)
-    end
-  end
-
-  describe '#summary' do
-    it 'Properly gets title of project' do
-      project = ProjectHelper.get_default_project(:client => @client)
-
-      res = project.summary
-      expect(res).to include(ProjectHelper::PROJECT_SUMMARY)
-    end
-  end
-
-  describe '#title' do
-    it 'Properly gets title of project' do
-      project = ProjectHelper.get_default_project(:client => @client)
-
-      res = project.title
-      expect(res).to include(ProjectHelper::PROJECT_TITLE)
-    end
-  end
-end
+  # describe '#users' do
+  #   it 'Returns array of GoodData::Users' do
+  # 
+  #     invitations = @project.invitations
+  #     expect(invitations).to_not be_nil
+  #     expect(invitations).to be_instance_of(Array)
+  # 
+  #     users = @project.users
+  #     expect(users).to be_instance_of(Array)
+  # 
+  #     users.each do |user|
+  #       expect(user).to be_instance_of(GoodData::Membership)
+  # 
+  #       roles = user.roles
+  #       expect(roles).to_not be_nil
+  #       expect(roles).to be_instance_of(Array)
+  # 
+  #       roles.each do |role|
+  #         expect(role).to be_instance_of(GoodData::ProjectRole)
+  #       end
+  # 
+  #       permissions = user.permissions
+  #       expect(permissions).to_not be_nil
+  #       expect(permissions).to_not be_nil
+  #       expect(permissions).to be_instance_of(Hash)
+  # 
+  #       # invitations = user.invitations
+  #       # invitations.should_not be_nil
+  # 
+  #       if (user.email == 'tomas.korcak@gooddata.com')
+  #         projects = user.projects
+  #         expect(projects).to_not be_nil
+  #         expect(projects).to be_instance_of(Array)
+  # 
+  #         projects.each do |project|
+  #           expect(project).to be_instance_of(GoodData::Project)
+  #         end
+  #       end
+  #     end
+  #   end
+  # end
+  # 
+  # describe '#add_user' do
+  #   it 'Adding user without domain should fail if it is not in the project' do
+  #     user = ProjectHelper.create_random_user(@client)
+  #     expect do
+  #       @project.add_user(user, 'Admin')
+  #     end.to raise_exception(ArgumentError)
+  #   end
+  # 
+  #   it 'Adding user with domain should be added to a project' do
+  #     user = ProjectHelper.create_random_user(@client)
+  #     @domain.create_users([user])
+  #     res = @project.add_user(user, 'Admin', domain: @domain)
+  #     expect(@project.member?(res['projectUsersUpdateResult']['successful'].first)).to be_truthy
+  #   end
+  # end
+  # 
+  # describe '#add_users' do
+  #   it 'Adding user without domain should fail if it is not in the project' do
+  #     users = (1..5).to_a.map do |x|
+  #       {
+  #         user: ProjectHelper.create_random_user(@client),
+  #         role: 'Admin'
+  #       }
+  #     end
+  #     res = @project.add_users(users)
+  #     expect(res.all? { |x| x[:type] == :error }).to eq true
+  #   end
+  # 
+  #   it 'Adding users with domain should pass and users should be added to domain' do
+  #     users = (1..5).to_a.map do |x|
+  #       {
+  #         user: ProjectHelper.create_random_user(@client),
+  #         role: 'Admin'
+  #       }
+  #     end
+  #     @domain.create_users(users.map {|u| u[:user]})
+  #     res = @project.add_users(users, domain: @domain)
+  #     links = res.map {|i| i[:result]['projectUsersUpdateResult']['successful'].first}
+  #     expect(@project.members?(links).all?).to be_truthy
+  #     # users.map { |r| r[:user] }.each { |u| u.delete }
+  #   end
+  # end
+  # 
+  # describe '#import_users' do
+  #   it "Updates user's name and surname and removes the users" do
+  #     users = (1..2).to_a.map { |x| ProjectHelper.create_random_user(@client) }
+  #     @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+  #     expect(@domain.members?(users)).to be_truthy
+  #     expect(@project.members?(users)).to be_truthy
+  #     expect(@project.members.count).to eq 3
+  #     # update some user stuff
+  #     bill = users[0]
+  #     bill.first_name = 'buffalo'
+  #     bill.last_name = 'bill'
+  #     # import
+  #     @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+  #     # it should be updated
+  #     bill_changed = @domain.get_user(bill)
+  #     expect(bill_changed.first_name).to eql('buffalo')
+  #     expect(bill_changed.last_name).to eql('bill')
+  #     expect(@project.members?(users)).to be_truthy
+  #     expect(@project.members.count).to eq 3
+  #     expect(@project.member?(bill_changed)).to be_truthy
+  # 
+  #     # remove everybody but buffalo bill.
+  #     @project.import_users([bill], domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+  #     expect(@project.members.count).to eq 2
+  #     expect(@project.member?(bill)).to be_truthy
+  #     expect(@project.members?(users - [bill]).any?).to be_falsey
+  # 
+  #     # Add additional user while changing Buffalos surname and role.
+  #     bill.last_name = 'Billie'
+  #     other_guy = ProjectHelper.create_random_user(@client)
+  # 
+  #     additional_batch = [bill, other_guy].map { |u| {user: u, role: u.role} }
+  #     @project.import_users(additional_batch, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+  #     expect(@project.members.count).to eq 3
+  #     expect(@project.member?(bill)).to be_truthy
+  #     expect(@project.members?(users - additional_batch.map {|x| x[:user]}).any?).to be_falsey
+  #   end
+  # 
+  #   it "Updates user's role in a project" do
+  #     users = (1..5).to_a.map { |x| ProjectHelper.create_random_user(@client).to_hash }
+  #     @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+  # 
+  #     expect(@project.members?(users)).to be_truthy
+  #     user_role_changed = users[1]
+  #     users_unchanged = users - [user_role_changed]
+  #     new_role = users[1][:role] = users[1][:role] == "admin" ? "editor" : "admin"
+  #     @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+  #     expect(@project.get_user(user_role_changed).role.identifier).to eql("#{new_role}Role")
+  #     expect(users_unchanged.map {|u| @project.get_user(u)}.map(&:role).map(&:title).uniq).to eq ['Editor']
+  #   end
+  # 
+  #   it "ignores user from both project and end state batch when whitelisted" do
+  #     u = @project.get_user(ConnectionHelper::DEFAULT_USERNAME)
+  #     uh = u.to_hash
+  #     uh[:role] = 'editor'
+  # 
+  #     users = (1..5).to_a.map { |x| ProjectHelper.create_random_user(@client).to_hash } + [uh]
+  #     expect(@project.member?(u)).to be_truthy
+  #     expect(u.role.title).to eq 'Admin'
+  #     @project.import_users(users, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+  #     expect(@project.member?(u)).to be_truthy
+  #     expect(@project.members?(users).all?).to be_truthy
+  #     expect(@project.get_user(ConnectionHelper::DEFAULT_USERNAME).role.title).to eq 'Admin'
+  #   end
+  # 
+  # end
+  # 
+  # describe '#set_user_roles' do
+  #   it 'Properly updates user roles as needed' do
+  #     users_to_import = @domain.users.sample(5).map {|u| { user: u, role: 'admin' }}
+  #     @project.import_users(users_to_import, domain: @domain, whitelists: [/gem_tester@gooddata.com/])
+  #     users_without_owner = @project.users.reject { |u| u.login == ConnectionHelper::DEFAULT_USERNAME }.pselect { |u| u.role.title == 'Admin' }
+  # 
+  #     user_to_change = users_without_owner.sample
+  #     @project.set_user_roles(user_to_change, 'editor')
+  #     expect(user_to_change.role.title).to eq 'Editor'
+  #     @project.set_user_roles(user_to_change, 'admin')
+  #     expect(user_to_change.role.title).to eq 'Admin'
+  # 
+  #     # Try different notation
+  #     @project.set_users_roles([user: user_to_change, role: 'editor'])
+  #     expect(user_to_change.role.title).to eq 'Editor'
+  #     @project.set_users_roles([user: user_to_change, role: 'admin'])
+  #     expect(user_to_change.role.title).to eq 'Admin'
+  #   end
+  # 
+  #   it 'Properly updates user roles when user specified by email and :roles specified as array of string with role names' do
+  #     # pick non deleted users that are not owner and have other roles than admin or editor
+  #     users = @project.users
+  #     users_without_owner = users
+  #       .reject { |u| u.login == ConnectionHelper::DEFAULT_USERNAME }
+  #       .reject { |u| u.login =~ /^deleted/ }
+  #       .pselect { |u| u.role.title =~ /^(Admin|Editor)/ }
+  # 
+  #     # take 10 users that we will exercise
+  #     users_to_change = users_without_owner.sample(10)
+  # 
+  #     # alternate roles and prepare structure
+  #     logins = users_to_change.map(&:login)
+  #     roles = users_to_change.map { |u| u.role.title == 'Admin' ? ['Editor'] : ['Admin'] }
+  # 
+  #     list = users_to_change.map do |u|
+  #       {
+  #         :user => u.login,
+  #         :roles => u.role.title == 'Admin' ? ['Editor'] : ['Admin']
+  #       }
+  #     end
+  # 
+  #     # set the roles
+  #     res = @project.set_users_roles(list)
+  #     expect(res.length).to equal(list.length)
+  #     expect(logins.map {|l| users.find {|u| u.login == l}}.pmap {|u| u.role.title}).to eq roles.flatten
+  #   end
+  # 
+  #   it 'Properly updates user roles when user specified by email and :roles specified as string with role name' do
+  #     users = @project.users
+  #     users_without_owner = users
+  #       .reject { |u| u.login == ConnectionHelper::DEFAULT_USERNAME }
+  #       .reject(&:deleted?)
+  #       .pselect { |u| u.role.title =~ /^(Admin|Editor)/ }
+  # 
+  #     users_to_change = users_without_owner.sample(10)
+  # 
+  #     logins = users_to_change.map(&:login)
+  #     roles = users_to_change.map { |u| u.role.title == 'Admin' ? 'Editor' : 'Admin' }
+  # 
+  #     list = users_to_change.map do |u|
+  #       {
+  #         :user => u.login,
+  #         :roles => u.role.title == 'Admin' ? 'Editor' : 'Admin'
+  #       }
+  #     end
+  # 
+  #     res = @project.set_users_roles(list)
+  #     expect(res.length).to equal(list.length)
+  #     expect(logins.map {|l| users.find {|u| u.login == l}}.pmap {|u| u.role.title}).to eq roles.flatten
+  #     
+  #   end
+  # end
+  # 
+  # describe '#summary' do
+  #   it 'Properly gets summary of project' do
+  #     res = @project.summary
+  #     expect(res).to include(ProjectHelper::PROJECT_SUMMARY)
+  #   end
+  # end
+  # 
+  # describe '#title' do
+  #   it 'Properly gets title of project' do
+  #     res = @project.title
+  #     expect(res).to include(ProjectHelper::PROJECT_TITLE)
+  #   end
+  # end
+  # 
+  # describe 'enabling and disabling users' do
+  #   it 'should be able to enable and disable a user' do
+  #     users_without_owner = @project.users
+  #       .reject { |u| u.login == ConnectionHelper::DEFAULT_USERNAME }
+  #       .reject(&:deleted?)
+  #       .select(&:enabled?)
+  #     user = users_without_owner.sample
+  #     expect(user.enabled?).to be_truthy
+  #     expect(user.disabled?).to be_falsey
+  #     user.disable
+  #     expect(user.disabled?).to be_truthy
+  #     expect(user.enabled?).to be_falsey
+  #     user.enable
+  #     expect(user.enabled?).to be_truthy
+  #     expect(user.disabled?).to be_falsey
+  #     expect(user.project).not_to be_nil
+  #   end
+  # end
+end