stormpath-sdk 1.3.0 → 1.3.1

data/spec/resource/email_template_spec.rb

@@ -1,20 +1,17 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::EmailTemplate, :vcr do
-  describe "instances should respond to attribute property methods" do
-    let(:application) { test_application }
-    let(:directory) { test_api_client.directories.create(name: random_directory_name) }
+  let(:application) { test_api_client.applications.create(build_application) }
+
+  after { application.delete }
+
+  describe 'instances should respond to attribute property methods' do
+    let(:directory) { test_api_client.directories.create(build_directory) }
     let(:password_policy) { directory.password_policy }
     let(:reset_email_template) { password_policy.reset_email_templates.first }
 
     before do
-      test_api_client.account_store_mappings.create(
-        application: application,
-        account_store: directory,
-        list_index: 1,
-        is_default_account_store: false,
-        is_default_group_store: false
-      )
+      map_account_store(application, directory, 1, false, false)
     end
 
     after { directory.delete }
@@ -35,25 +32,25 @@ describe Stormpath::Resource::EmailTemplate, :vcr do
     end
 
     it 'can change attributes' do
-      reset_email_template.name = "Default Password Reset Template"
-      reset_email_template.description = "This is the password reset email template"
-      reset_email_template.subject = "Please reset your password"
-      reset_email_template.from_email_address = "email@stormpath.com"
-      reset_email_template.text_body = "You forgot your password! ${sptoken}"
-      reset_email_template.html_body = "<p> You forgot your password! </p> ${sptoken}"
-      reset_email_template.mime_type = "text/plain"
+      reset_email_template.name = 'Default Password Reset Template'
+      reset_email_template.description = 'This is the password reset email template'
+      reset_email_template.subject = 'Please reset your password'
+      reset_email_template.from_email_address = "email#{default_domain}"
+      reset_email_template.text_body = 'You forgot your password! ${sptoken}'
+      reset_email_template.html_body = '<p> You forgot your password! </p> ${sptoken}'
+      reset_email_template.mime_type = 'text/plain'
 
       reset_email_template.save
 
       reloaded_reset_email_template = password_policy.reset_email_templates.first
 
-      expect(reloaded_reset_email_template.name).to eq("Default Password Reset Template")
-      expect(reloaded_reset_email_template.description).to eq("This is the password reset email template")
-      expect(reloaded_reset_email_template.subject).to eq("Please reset your password")
-      expect(reloaded_reset_email_template.from_email_address).to eq("email@stormpath.com")
-      expect(reloaded_reset_email_template.text_body).to eq("You forgot your password! ${sptoken}")
-      expect(reloaded_reset_email_template.html_body).to eq("<p> You forgot your password! </p> ${sptoken}")
-      expect(reloaded_reset_email_template.mime_type).to eq("text/plain")
+      expect(reloaded_reset_email_template.name).to eq('Default Password Reset Template')
+      expect(reloaded_reset_email_template.description).to eq('This is the password reset email template')
+      expect(reloaded_reset_email_template.subject).to eq('Please reset your password')
+      expect(reloaded_reset_email_template.from_email_address).to eq("email#{default_domain}")
+      expect(reloaded_reset_email_template.text_body).to eq('You forgot your password! ${sptoken}')
+      expect(reloaded_reset_email_template.html_body).to eq('<p> You forgot your password! </p> ${sptoken}')
+      expect(reloaded_reset_email_template.mime_type).to eq('text/plain')
     end
   end
 end

data/spec/resource/group_membership_spec.rb

@@ -1,28 +1,25 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::GroupMembership, :vcr do
-  it "should be the same as AccountMembership" do
+  it 'should be the same as AccountMembership' do
     expect(Stormpath::Resource::GroupMembership).to eq(Stormpath::Resource::AccountMembership)
   end
 
   describe '#add_account' do
-    context "given an account and a group" do
-
-      let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-      let(:group) { directory.groups.create name: 'someGroup' }
-
-      let(:account) { directory.accounts.create({ email: 'rubysdk@example.com', given_name: 'Ruby SDK', password: 'P@$$w0rd', surname: 'SDK' }) }
+    context 'given an account and a group' do
+      let(:directory) { test_api_client.directories.create(build_directory) }
+      let(:group) { directory.groups.create(build_group) }
+      let(:account) { directory.accounts.create(build_account) }
 
       before { group.add_account account }
 
       after do
-        group.delete if group
-        directory.delete if directory
-        account.delete if account
+        group.delete
+        account.delete
+        directory.delete
       end
 
-      it ", group membership and account membership should correspond to each other" do
+      it 'group membership and account membership should correspond to each other' do
         expect(group.account_memberships.count).to eq(1)
         expect(account.group_memberships.count).to eq(1)
         expect(group.accounts).to include(account)

data/spec/resource/group_spec.rb

@@ -1,26 +1,24 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::Group, :vcr do
+  let(:directory) { test_api_client.directories.create(build_directory) }
+  after { directory.delete }
 
-  describe "instances should respond to attribute property methods" do
-    let(:directory) { test_directory }
+  describe 'instances should respond to attribute property methods' do
+    let(:group) { directory.groups.create name: 'RubyTestGroup', description: 'testDescription' }
 
-    let(:group) { directory.groups.create name: 'someTestGroup', description: 'someTestDescription' }
-
-    after do
-      group.delete if group
-    end
+    after { group.delete }
 
     it do
       [:name, :description, :status].each do |property_accessor|
         expect(group).to respond_to(property_accessor)
         expect(group).to respond_to("#{property_accessor}=")
-        expect(group.send property_accessor).to be_a String
+        expect(group.send(property_accessor)).to be_a String
       end
 
       [:created_at, :modified_at].each do |property_getter|
         expect(group).to respond_to(property_getter)
-        expect(group.send property_getter).to be_a String
+        expect(group.send(property_getter)).to be_a String
       end
 
       expect(group.tenant).to be_a Stormpath::Resource::Tenant
@@ -32,36 +30,27 @@ describe Stormpath::Resource::Group, :vcr do
   end
 
   describe '#create_group_with_custom_data' do
-    let(:directory) { test_directory }
-
     it 'creates a directory with custom data' do
-      directory.custom_data["category"] = "classified"
+      directory.custom_data['category'] = 'classified'
 
       directory.save
-      expect(directory.custom_data["category"]).to eq("classified")
+      expect(directory.custom_data['category']).to eq('classified')
     end
   end
 
   describe '#add_or_remove_account' do
-    context "given an account" do
-
-      let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-      let(:group) { directory.groups.create name: 'someGroup' }
+    context 'given an account' do
+      let(:group) { directory.groups.create(build_group) }
+      let(:account) { directory.accounts.create(build_account) }
 
-      let(:account) { directory.accounts.create({ email: 'rubysdk@example.com', given_name: 'Ruby SDK', password: 'P@$$w0rd',surname: 'SDK' }) }
-
-      before do
-        group.add_account account
-      end
+      before { group.add_account(account) }
 
       after do
-        group.delete if group
-        directory.delete if directory
-        account.delete if account
+        group.delete
+        account.delete
       end
 
-      it "adds the account to the group" do
+      it 'adds the account to the group' do
         expect(group.accounts).to include(account)
       end
 
@@ -71,12 +60,9 @@ describe Stormpath::Resource::Group, :vcr do
 
       it 'adds and removes the group from the account' do
         expect(group.accounts).to include(account)
-
-        group.remove_account account
-
+        group.remove_account(account)
         expect(group.accounts).not_to include(account)
       end
-
     end
   end
 end

data/spec/resource/linked_account_spec.rb

@@ -7,28 +7,15 @@ describe Stormpath::Resource::LinkedAccount, :vcr do
   let(:directory1) { test_api_client.directories.create(name: 'ruby sdk dir 1') }
   let(:directory2) { test_api_client.directories.create(name: 'ruby sdk dir 2') }
   let(:account1) do
-    directory1.accounts.create(build_account(email: 'jekyll@example.com', username: 'account1'))
+    directory1.accounts.create(build_account(email: 'jekyll', username: 'jekyll'))
   end
   let(:account2) do
-    directory2.accounts.create(build_account(email: 'hyde@example.com', username: 'account2'))
+    directory2.accounts.create(build_account(email: 'hyde', username: 'hyde'))
   end
 
   before do
-    test_api_client.account_store_mappings.create(
-      application: application,
-      account_store: directory1,
-      list_index: 1,
-      is_default_account_store: true,
-      is_default_group_store: false
-    )
-
-    test_api_client.account_store_mappings.create(
-      application: application,
-      account_store: directory2,
-      list_index: 2,
-      is_default_account_store: false,
-      is_default_group_store: false
-    )
+    map_account_store(application, directory1, 1, true, false)
+    map_account_store(application, directory2, 2, false, false)
 
     test_api_client.account_links.create(
       left_account: {

data/spec/resource/organization_spec.rb

@@ -1,36 +1,25 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::Organization, :vcr do
-
   let(:organization) do
-    test_api_client.organizations.create name: 'test_ruby_organization',
-       name_key: "testorganization", description: 'test organization'
+    test_api_client.organizations.create(build_organization(name: 'test_ruby_organization',
+                                                            name_key: 'testorganization',
+                                                            description: 'test organization'))
   end
 
-  after do
-    organization.delete if organization
-  end
+  after { organization.delete if organization }
 
-  def create_organization_account_store_mapping(organization, account_store, options = {})
-    test_api_client.organization_account_store_mappings.create(
-      account_store: { href: account_store.href },
-      organization: { href: organization.href },
-      is_default_account_store: options[:default_account_store] || false,
-      is_default_group_store: options[:default_group_store] || false
-    )
-  end
-
-  describe "instances should respond to attribute property methods" do
+  describe 'instances should respond to attribute property methods' do
     it do
       [:name, :description, :name_key, :status].each do |property_accessor|
         expect(organization).to respond_to(property_accessor)
         expect(organization).to respond_to("#{property_accessor}=")
-        expect(organization.send property_accessor).to be_a String
+        expect(organization.send(property_accessor)).to be_a String
       end
 
       [:created_at, :modified_at].each do |property_getter|
         expect(organization).to respond_to(property_getter)
-        expect(organization.send property_getter).to be_a String
+        expect(organization.send(property_getter)).to be_a String
       end
 
       expect(organization.tenant).to be_a Stormpath::Resource::Tenant
@@ -41,7 +30,7 @@ describe Stormpath::Resource::Organization, :vcr do
   end
 
   describe 'get resource' do
-    let(:fetched_organization) { test_api_client.organizations.get organization.href }
+    let(:fetched_organization) { test_api_client.organizations.get(organization.href) }
 
     it 'returns the organization resource with correct attribute properties' do
       expect(fetched_organization).to be_kind_of(Stormpath::Resource::Organization)
@@ -50,8 +39,10 @@ describe Stormpath::Resource::Organization, :vcr do
       expect(fetched_organization.name_key).to eq(organization.name_key)
       expect(fetched_organization.status).to eq(organization.status)
       expect(fetched_organization.account_store_mappings).to eq(organization.account_store_mappings)
-      expect(fetched_organization.default_account_store_mapping).to eq(organization.default_account_store_mapping)
-      expect(fetched_organization.default_group_store_mapping).to eq(organization.default_group_store_mapping)
+      expect(fetched_organization.default_account_store_mapping)
+        .to eq(organization.default_account_store_mapping)
+      expect(fetched_organization.default_group_store_mapping)
+        .to eq(organization.default_group_store_mapping)
     end
 
     it 'returns custom_data' do
@@ -61,30 +52,23 @@ describe Stormpath::Resource::Organization, :vcr do
 
   describe 'create' do
     context 'invalid data' do
+      before { organization }
+
       it 'should raise Stormpath::Error' do
         expect do
-          test_api_client.organizations.create name: 'test_organization',
-            name_key: "test_org"
+          test_api_client.organizations.create(build_organization(name_key: 'testorganization'))
         end.to raise_error(Stormpath::Error)
       end
     end
   end
 
   describe 'associations' do
-    context 'groups' do
-
-      let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-      let(:group) { directory.groups.create name: "test_group" }
-
-      before do
-        create_organization_account_store_mapping(organization, group)
-      end
+    let(:directory) { test_api_client.directories.create(build_directory) }
+    after { directory.delete }
 
-      after do
-        organization.delete if organization
-        directory.delete if directory
-      end
+    context 'groups' do
+      let(:group) { directory.groups.create(name: 'test_group') }
+      before { map_organization_store(group, organization) }
 
       it 'returns a collection of groups' do
         expect(organization.groups).to be_kind_of(Stormpath::Resource::Collection)
@@ -93,35 +77,10 @@ describe Stormpath::Resource::Organization, :vcr do
     end
 
     context 'accounts' do
-      let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-      let(:account) do
-        directory.accounts.create(
-          email: 'rubysdk@example.com',
-          given_name: 'Ruby SDK',
-          password: 'P@$$w0rd',
-          surname: 'SDK'
-        )
-      end
-      let(:org_account) do
-        organization.accounts.create(
-          email: 'rubysdk2@example.com',
-          given_name: 'Ruby SDK',
-          password: 'P@$$w0rd',
-          surname: 'SDK'
-        )
-      end
+      let(:account) { directory.accounts.create(build_account(email: 'rubysdk')) }
+      let(:org_account) { directory.accounts.create(build_account(email: 'rubysdk2')) }
 
-      before do
-        create_organization_account_store_mapping(organization,
-                                                  directory,
-                                                  default_account_store: true)
-      end
-
-      after do
-        organization.delete if organization
-        directory.delete if directory
-      end
+      before { map_organization_store(directory, organization, true) }
 
       it 'returns a collection of accounts' do
         expect(organization.accounts).to be_kind_of(Stormpath::Resource::Collection)
@@ -140,16 +99,7 @@ describe Stormpath::Resource::Organization, :vcr do
     end
 
     context 'tenant' do
-      let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-      before do
-        create_organization_account_store_mapping(organization, directory)
-      end
-
-      after do
-        organization.delete if organization
-        directory.delete if directory
-      end
+      before { map_organization_store(directory, organization) }
 
       it 'returns tenant' do
         expect(organization.tenant).to eq(directory.tenant)
@@ -159,45 +109,33 @@ describe Stormpath::Resource::Organization, :vcr do
 
   describe 'delete' do
     let(:href) { organization.href }
-
-    before do
-      organization.delete
-    end
+    before { organization.delete }
 
     it 'removes the organization' do
-      expect do
-        test_api_client.organizations.get href
-      end.to raise_error(Stormpath::Error)
+      expect { test_api_client.organizations.get(href) }.to raise_error(Stormpath::Error)
     end
   end
 
   describe 'update' do
     before do
-      organization.name_key = "changed-test-organization"
+      organization.name_key = 'changed-test-organization'
       organization.save
     end
 
     it 'can change the data of the existing organization' do
-      org = test_api_client.organizations.get organization.href
-      expect(org.name_key).to eq("changed-test-organization")
+      org = test_api_client.organizations.get(organization.href)
+      expect(org.name_key).to eq('changed-test-organization')
     end
   end
 
   describe 'organization account store mapping' do
-    context 'given an account_store is a directory' do
-      let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-      let(:organization_account_store_mapping) do
-        create_organization_account_store_mapping(organization, directory)
-      end
+    let(:directory) { test_api_client.directories.create(build_directory) }
+    after { directory.delete }
 
+    context 'given an account_store is a directory' do
+      let(:organization_account_store_mapping) { map_organization_store(directory, organization) }
       let(:reloaded_mapping) do
-        test_api_client.account_store_mappings.get organization_account_store_mapping.href
-      end
-
-      after do
-        organization.delete if organization
-        directory.delete if directory
+        test_api_client.account_store_mappings.get(organization_account_store_mapping.href)
       end
 
       it 'should return a directory' do
@@ -207,23 +145,13 @@ describe Stormpath::Resource::Organization, :vcr do
     end
 
     context 'given an account_store is a group' do
-      let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-      let(:group) { directory.groups.create name: "test_group" }
-
-      let(:organization_account_store_mapping) do
-        create_organization_account_store_mapping(organization, group)
-      end
-
+      let(:group) { directory.groups.create(name: 'test_group') }
+      let(:organization_account_store_mapping) { map_organization_store(group, organization) }
       let(:reloaded_mapping) do
-        test_api_client.account_store_mappings.get organization_account_store_mapping.href
+        test_api_client.account_store_mappings.get(organization_account_store_mapping.href)
       end
 
-      after do
-        organization.delete if organization
-        group.delete if group
-        directory.delete if directory
-      end
+      after { group.delete }
 
       it 'should return group' do
         expect(reloaded_mapping.account_store.class).to eq(Stormpath::Resource::Group)