practical 0.1.0 → 3.0.0.pre.alpha1

data/app/lib/practical/test/shared/memberships/models/membership/base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Models::Membership::Base
+  extend ActiveSupport::Concern
+
+  included do
+    test "state: has at least the base set of cases" do
+      expected_states = [
+        :pending_reacceptance,
+        :active,
+        :archived_by_organization,
+        :archived_by_user,
+      ].map(&:to_sym).to_set
+
+      actual = model_class.states.keys.map(&:to_sym).to_set
+
+      assert_equal true, expected_states.subset?(actual), [expected_states, actual]
+    end
+
+    test "belongs_to the user resource" do
+      reflection = model_class.reflect_on_association(user_reflection_name)
+      assert_equal :belongs_to, reflection.macro
+    end
+
+    test "belongs_to the organization resource" do
+      reflection = model_class.reflect_on_association(organization_reflection_name)
+      assert_equal :belongs_to, reflection.macro
+    end
+
+    test "user: must be unique for an organization" do
+      instance = model_instance
+
+      assert_equal true, instance.valid?
+
+      new_instance = instance.send(:"#{user_reflection_name}").memberships.build(organization: organization_instance)
+
+      assert_equal false, new_instance.valid?
+      assert_equal true, new_instance.errors.of_kind?(:user, :taken)
+
+      new_instance = other_user_instance.memberships.build(organization: instance.organization)
+      new_instance.valid?
+      assert_equal false, new_instance.errors.of_kind?(:user, :taken)
+    end
+  end
+end

data/app/lib/practical/test/shared/memberships/models/membership_invitation/base.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Models::MembershipInvitation::Base
+  extend ActiveSupport::Concern
+
+  included do
+    test "belongs_to an organization" do
+      reflection = model_class.reflect_on_association(organization_reflection_name)
+      assert_equal :belongs_to, reflection.macro
+    end
+
+    test "optionally belongs_to a user" do
+      reflection = model_class.reflect_on_association(user_reflection_name)
+      assert_equal :belongs_to, reflection.macro
+      assert_equal user_class.to_s, reflection.class_name
+      assert_equal true, reflection.options[:optional]
+    end
+
+    test "optionally belongs_to a membership" do
+      reflection = model_class.reflect_on_association(membership_reflection_name)
+      assert_equal :belongs_to, reflection.macro
+      assert_equal membership_class.to_s, reflection.class_name
+      assert_equal true, reflection.options[:optional]
+    end
+
+    test "does not require a membership or user" do
+      instance = valid_new_instance
+      assert_equal true, instance.valid?
+      assert_nil valid_new_instance.user
+      assert_nil valid_new_instance.membership
+    end
+
+    test "requires an organization" do
+      instance = valid_new_instance
+      instance.organization = nil
+      assert_equal false, instance.valid?
+      assert_equal true, instance.errors.of_kind?(organization_reflection_name, :blank)
+    end
+
+    test "requires a non-blank email" do
+      instance = valid_new_instance
+      instance.email = nil
+      assert_equal false, instance.valid?
+      assert_equal true, instance.errors.of_kind?(:email, :blank)
+
+      instance.email = ""
+      assert_equal false, instance.valid?
+      assert_equal true, instance.errors.of_kind?(:email, :blank)
+
+      instance.email = "    "
+      assert_equal false, instance.valid?
+      assert_equal true, instance.errors.of_kind?(:email, :blank)
+    end
+
+    test "an organization can only create 1 invitation per email" do
+      organization = organization_instance
+      email = Faker::Internet.email
+      instance_1 = create_new_instance(organization: organization, email: email)
+
+      duplicate_instance = valid_new_instance
+      duplicate_instance.email = email
+      duplicate_instance.organization = organization
+
+      assert_equal false, duplicate_instance.valid?
+      assert_equal true, duplicate_instance.errors.of_kind?(:email, :taken)
+    end
+
+    test "unused scope returns all unused invitations" do
+      assert_equal true, model_class.all.any?{|x| x.user.present?}
+
+      invitations = model_class.unused
+      assert_not_empty invitations
+      assert_equal true, invitations.all?{|x| x.user.nil? }
+    end
+
+    test "visible scope returns all visible invitations" do
+      hidden_invitation = hidden_instance
+
+      assert_equal false, hidden_invitation.visible?
+
+      assert_not_empty model_class.visible
+      assert_not_includes model_class.visible, hidden_invitation
+    end
+  end
+end

data/app/lib/practical/test/shared/memberships/models/membership_invitation/sending.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Models::MembershipInvitation::Sending
+  extend ActiveSupport::Concern
+
+  included do
+    test "belongs_to an sender" do
+      reflection = model_class.reflect_on_association(sender_reflection_name)
+      assert_equal :belongs_to, reflection.macro
+    end
+
+    test "generates_token_for invitation that expires when the user is set" do
+      instance = valid_new_instance
+      instance.save!
+
+      token = instance.generate_token_for(:invitation)
+
+      assert_equal instance, model_class.find_by_token_for(:invitation, token)
+
+      instance.update!(user: user_instance)
+
+      assert_nil model_class.find_by_token_for(:invitation, token)
+    end
+
+    test "only validates that the sender has a membership in the organization on creation" do
+      invitation = valid_new_instance
+      other_user = other_user_instance_with_admin_privledges
+
+      assert_not_includes other_user.organizations, invitation.organization
+
+      invitation.sender = other_user
+
+      assert_equal false, invitation.valid?
+      assert_equal true, invitation.errors.of_kind?(:sender, :cannot_manage_organization)
+
+      invitation.sender = other_user_instance_without_admin_privledges
+
+      assert_equal false, invitation.valid?
+      assert_equal true, invitation.errors.of_kind?(:sender, :cannot_manage_organization)
+
+      invitation.sender = user_in_organization
+
+      assert_equal true, invitation.valid?
+
+      invitation.save!
+
+      assert_equal true, invitation.valid?
+
+      invitation.sender = other_user_instance_without_admin_privledges
+      assert_equal true, invitation.valid?
+    end
+
+    test "can_be_resent?: has a 10 minute waiting period" do
+      membership_invitation = model_class.first
+
+      assert_nil membership_invitation.last_sent_at
+      assert_equal true, membership_invitation.can_be_resent?
+
+      time = Time.now.utc
+
+      membership_invitation.update!(last_sent_at: time)
+
+      Timecop.freeze(time + 2.minutes) do
+        assert_equal false, membership_invitation.can_be_resent?
+      end
+
+      Timecop.freeze(time + 5.minutes) do
+        assert_equal false, membership_invitation.can_be_resent?
+      end
+
+      Timecop.freeze(time + 10.minutes) do
+        assert_equal true, membership_invitation.can_be_resent?
+      end
+    end
+  end
+end

data/app/lib/practical/test/shared/memberships/models/membership_invitation/use_for_and_notify.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Models::MembershipInvitation::UseForAndNotify
+  extend ActiveSupport::Concern
+
+  included do
+    test "use_for_and_notify!: raises AlreadyUsedError if a user is present" do
+      invitation = instance_with_user
+
+      assert_raises model_class::AlreadyUsedError do
+        invitation.use_for_and_notify!(user: other_user)
+      end
+    end
+
+    test "use_for_and_notify!: raises an ActiveRecord::RecordInvalid error if a membership already exists somehow for this user + organization" do
+      user = invited_user_instance
+      invitation = model_class.find_by!(email: user.email)
+
+      invitation.organization.memberships.create!(
+        user: user, membership_type: :staff, state: :pending_reacceptance
+      )
+
+      assert_raises ActiveRecord::RecordInvalid do
+        invitation.use_for_and_notify!(user: user)
+      end
+    end
+
+    test """use_for_and_notify!:
+    - links to the given user
+    - creates the Membership with the stored membership_type
+    - matching mailer class: passkey_added
+    """ do
+      user = invited_user_instance
+
+      invitation = model_class.find_by(email: user.email)
+
+      assert_difference "Membership.count", +1 do
+        invitation.use_for_and_notify!(user: user)
+        invitation.reload
+
+        assert_equal user, invitation.user
+        assert_equal true, invitation.membership.active?
+        assert_equal user, invitation.membership.user
+        assert_equal invitation.organization, invitation.membership.organization
+        additional_membership_accept_assertions(invitation: invitation)
+      end
+
+      assert_enqueued_email_with(
+        mailer_class,
+        :invitation_accepted,
+        args: [{ membership_invitation: invitation }]
+      )
+    end
+  end
+end

data/app/lib/practical/test/shared/memberships/models/organization/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Models::Organization::Base
+  extend ActiveSupport::Concern
+
+  included do
+    test "has_many membership resource, dependent: :destroy" do
+      reflection = model_class.reflect_on_association(membership_reflection_name)
+      assert_equal :has_many, reflection.macro
+      assert_equal :destroy, reflection.options[:dependent]
+    end
+
+    test "has_many membership_invitations resource, dependent: :destroy" do
+      reflection = model_class.reflect_on_association(membership_invitation_reflection_name)
+      assert_equal :has_many, reflection.macro
+      assert_equal :destroy, reflection.options[:dependent]
+    end
+
+    test "has_many users resource, through: :memberships resource" do
+      reflection = model_class.reflect_on_association(user_reflection_name)
+      assert_equal :has_many, reflection.macro
+      assert_equal membership_reflection_name, reflection.options[:through]
+    end
+  end
+end

data/app/lib/practical/test/shared/memberships/models/user/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Models::User::Base
+  extend ActiveSupport::Concern
+
+  included do
+    test "has_many membership resource" do
+      reflection = model_class.reflect_on_association(membership_reflection_name)
+      assert_equal :has_many, reflection.macro
+    end
+
+    test "has_many membership_invitations resource" do
+      reflection = model_class.reflect_on_association(membership_invitation_reflection_name)
+      assert_equal :has_many, reflection.macro
+    end
+
+    test "has_many organizations resource, through: :memberships resource" do
+      reflection = model_class.reflect_on_association(organization_reflection_name)
+      assert_equal :has_many, reflection.macro
+      assert_equal membership_reflection_name, reflection.options[:through]
+    end
+  end
+end

data/app/lib/practical/test/shared/memberships/policies/organization/base_resource.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Policies::Organization::BaseResource
+  extend ActiveSupport::Concern
+  included do
+    class TestClass
+      attr_accessor :organization
+
+      def initialize(organization:)
+        self.organization = organization
+      end
+    end
+
+    class TestClassPolicy < policy_class
+      def show?
+        true
+      end
+    end
+
+    test "pre_check? the record is part of the same_organization?" do
+      organization = organizations.organization_1
+      record = TestClass.new(organization: organization)
+      other_record = TestClass.new(organization: organizations.organization_2)
+
+      assert_equal true, TestClassPolicy.new(record, user: users.organization_1_owner, organization: organization).apply(:show?)
+      assert_equal false, TestClassPolicy.new(other_record, user: users.organization_1_owner, organization: organization).apply(:show?)
+    end
+  end
+end

data/app/lib/practical/test/shared/memberships/policies/organization/membership.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Policies::Organization::Membership
+  extend ActiveSupport::Concern
+
+  included do
+    test "manage?: only true for memberships where the user has an organization_manager membership for the same organization" do
+      membership = users.works_at_org_1_and_2.memberships.find_by(organization: organizations.organization_1)
+
+      assert_equal true, policy_for(membership: membership, user: users.organization_1_owner).apply(:manage?)
+      assert_equal true, policy_for(membership: membership, user: users.organization_1_manager).apply(:manage?)
+
+      assert_equal false, policy_for(membership: membership, user: users.works_at_org_1_and_2).apply(:manage?)
+      assert_equal false, policy_for(membership: membership, user: users.archived_organization_1_manager).apply(:manage?)
+      assert_equal false, policy_for(membership: membership, user: users.organization_2_owner).apply(:manage?)
+      assert_equal false, policy_for(membership: membership, user: users.organization_1_staff).apply(:manage?)
+      assert_equal false, policy_for(membership: membership, user: users.retired_staff).apply(:manage?)
+    end
+
+    test "archive?: false if the user does not have an organization_manager membership in the same organization" do
+      membership = users.works_at_org_1_and_2.memberships.find_by(organization: organizations.organization_1)
+
+      assert_equal true, policy_for(membership: membership, user: users.organization_1_owner).apply(:archive?)
+      assert_equal true, policy_for(membership: membership, user: users.organization_1_manager).apply(:archive?)
+
+      assert_equal false, policy_for(membership: membership, user: users.works_at_org_1_and_2).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.archived_organization_1_manager).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.organization_2_owner).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.organization_1_staff).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.retired_staff).apply(:archive?)
+    end
+
+    test "archive?: true if the membership is not an organization_manager membership" do
+      membership = users.works_at_org_1_and_2.memberships.find_by(organization: organizations.organization_1)
+
+      assert_equal false, membership.organization_manager?
+
+      assert_equal true, policy_for(membership: membership, user: users.organization_1_owner).apply(:archive?)
+      assert_equal true, policy_for(membership: membership, user: users.organization_1_manager).apply(:archive?)
+
+      assert_equal false, policy_for(membership: membership, user: users.works_at_org_1_and_2).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.archived_organization_1_manager).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.organization_2_owner).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.organization_1_staff).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.retired_staff).apply(:archive?)
+    end
+
+    test "archive?: only true if the organization_manager membership can be removed" do
+      membership = users.organization_1_manager.memberships.find_by(organization: organizations.organization_1)
+
+      assert_equal true, membership.organization_manager?
+      assert_equal true, organization_policy(membership.organization, user: users.organization_1_owner).apply(:remove_organization_manager?)
+
+      assert_equal true, policy_for(membership: membership, user: users.organization_1_owner).apply(:archive?)
+      assert_equal true, policy_for(membership: membership, user: users.organization_1_manager).apply(:archive?)
+
+      assert_equal false, policy_for(membership: membership, user: users.works_at_org_1_and_2).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.archived_organization_1_manager).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.organization_2_owner).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.organization_1_staff).apply(:archive?)
+      assert_equal false, policy_for(membership: membership, user: users.retired_staff).apply(:archive?)
+
+      other_membership = users.organization_2_owner.memberships.find_by(organization: organizations.organization_2)
+      assert_equal true, membership.organization_manager?
+      assert_equal false, organization_policy(other_membership.organization, user: users.organization_2_owner).apply(:remove_organization_manager?)
+
+      assert_equal false, policy_for(membership: membership, user: users.organization_2_owner).apply(:archive?)
+    end
+
+    test "relation only returns the memberships that are part of the same organization" do
+      assert_equal_set(
+        organizations.organization_1.memberships,
+        policy_for(
+          membership: users.works_at_org_1_and_2.memberships.find_by(organization: organizations.organization_1),
+          user: users.organization_1_manager
+        ).apply_scope(all_memberships_relation, type: :active_record_relation)
+      )
+
+      assert_equal_set(
+        organizations.organization_2.memberships,
+        policy_for(
+          membership: users.works_at_org_1_and_2.memberships.find_by(organization: organizations.organization_2),
+          user: users.organization_2_owner
+        ).apply_scope(all_memberships_relation, type: :active_record_relation)
+      )
+
+      assert_equal_set(
+        organizations.organization_1.memberships,
+        policy_for(
+          membership: users.works_at_org_1_and_2.memberships.find_by(organization: organizations.organization_1),
+          user: users.works_at_org_1_and_2
+        ).apply_scope(all_memberships_relation, type: :active_record_relation)
+      )
+
+      assert_empty(
+        policy_for(
+          membership: users.works_at_org_1_and_2.memberships.find_by(organization: organizations.organization_1),
+          user: users.organization_2_owner
+        ).apply_scope(all_memberships_relation, type: :active_record_relation)
+      )
+    end
+  end
+end

data/app/lib/practical/test/shared/memberships/policies/organization/membership_invitation.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Policies::Organization::MembershipInvitation
+  extend ActiveSupport::Concern
+
+  included do
+    def assert_can_manage(invitation:, user:)
+      assert_equal true, policy_for(invitation: invitation, user: user).apply(:manage?)
+    end
+
+    def assert_cannot_manage(invitation:, user:)
+      assert_equal false, policy_for(invitation: invitation, user: user).apply(:manage?)
+    end
+
+    test "manage?: only true for memberships where the user has an organization_manager membership for the same organization" do
+      invitation = organizations.organization_1.membership_invitations.create!(
+        email: Faker::Internet.email,
+        sender: users.organization_1_owner,
+        membership_type: :staff
+      )
+
+      assert_equal true, policy_for(invitation: invitation, user: users.organization_1_owner).apply(:manage?)
+      assert_equal true, policy_for(invitation: invitation, user: users.organization_1_manager).apply(:manage?)
+
+      assert_equal false, policy_for(invitation: invitation, user: users.works_at_org_1_and_2).apply(:manage?)
+      assert_equal false, policy_for(invitation: invitation, user: users.archived_organization_1_manager).apply(:manage?)
+      assert_equal false, policy_for(invitation: invitation, user: users.organization_2_owner).apply(:manage?)
+      assert_equal false, policy_for(invitation: invitation, user: users.organization_1_staff).apply(:manage?)
+      assert_equal false, policy_for(invitation: invitation, user: users.retired_staff).apply(:manage?)
+    end
+
+    test "archive?: false if the user does not have an organization_manager membership in the same organization" do
+      invitation = organizations.organization_1.membership_invitations.create!(
+        email: Faker::Internet.email,
+        sender: users.organization_1_owner,
+        membership_type: :staff
+      )
+
+      assert_equal true, policy_for(invitation: invitation, user: users.organization_1_owner).apply(:archive?)
+      assert_equal true, policy_for(invitation: invitation, user: users.organization_1_manager).apply(:archive?)
+
+      assert_equal false, policy_for(invitation: invitation, user: users.works_at_org_1_and_2).apply(:archive?)
+      assert_equal false, policy_for(invitation: invitation, user: users.archived_organization_1_manager).apply(:archive?)
+      assert_equal false, policy_for(invitation: invitation, user: users.organization_2_owner).apply(:archive?)
+      assert_equal false, policy_for(invitation: invitation, user: users.organization_1_staff).apply(:archive?)
+      assert_equal false, policy_for(invitation: invitation, user: users.retired_staff).apply(:archive?)
+    end
+
+    test "relation only returns the membership_invitations that are part of the same organization" do
+      organizations.organization_1.membership_invitations.create!(
+        email: Faker::Internet.email,
+        sender: users.organization_1_owner,
+        membership_type: :staff
+      )
+
+      organizations.organization_2.membership_invitations.create!(
+        email: Faker::Internet.email,
+        sender: users.organization_2_owner,
+        membership_type: :staff
+      )
+
+      assert_equal_set(
+        organizations.organization_1.membership_invitations,
+        relation_policy_for(
+          organization: organizations.organization_1,
+          user: users.organization_1_manager
+        ).apply_scope(all_membership_invitations_relation, type: :active_record_relation)
+      )
+
+      assert_equal_set(
+        organizations.organization_2.membership_invitations,
+        relation_policy_for(
+          organization: organizations.organization_2,
+          user: users.organization_2_owner
+        ).apply_scope(all_membership_invitations_relation, type: :active_record_relation)
+      )
+
+      assert_equal_set(
+        organizations.organization_1.membership_invitations,
+        relation_policy_for(
+          organization: organizations.organization_1,
+          user: users.works_at_org_1_and_2
+        ).apply_scope(all_membership_invitations_relation, type: :active_record_relation)
+      )
+
+      assert_empty(
+        relation_policy_for(
+          organization: organizations.organization_1,
+          user: users.organization_2_owner
+        ).apply_scope(all_membership_invitations_relation, type: :active_record_relation)
+      )
+    end
+  end
+end

data/app/lib/practical/test/shared/memberships/policies/organization/resource/inherits.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Policies::Organization::Resource::Inherits
+  extend ActiveSupport::Concern
+  included do
+    test "is a subclass of the resource_policy_class" do
+      assert_includes policy_class.ancestors, resource_policy_class
+    end
+  end
+end

data/app/lib/practical/test/shared/memberships/policies/organization.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Practical::Test::Shared::Memberships::Policies::Organization
+  extend ActiveSupport::Concern
+  included do
+    test "default scope: returns all the organizations the user has access to" do
+      assert_equal_set(
+        [organizations.organization_1],
+        relation_policy(user: users.organization_1_owner)
+      )
+
+      assert_equal_set(
+        [organizations.organization_1],
+        relation_policy(user: users.organization_1_manager)
+      )
+
+      assert_equal_set(
+        [organizations.organization_1, organizations.organization_2],
+        relation_policy(user: users.works_at_org_1_and_2)
+      )
+
+      assert_equal_set(
+        [organizations.organization_2],
+        relation_policy(user: users.organization_2_owner)
+      )
+
+      assert_empty relation_policy(user: users.organization_1_staff)
+      assert_empty relation_policy(user: users.retired_staff)
+      assert_empty relation_policy(user: users.archived_organization_1_manager)
+    end
+
+    test "show?: only true when the user has an active membership" do
+      organization = organizations.organization_1
+
+      assert_equal true, policy(organization: organization, user: users.organization_1_owner).apply(:show?)
+      assert_equal true, policy(organization: organization, user: users.organization_1_manager).apply(:show?)
+      assert_equal true, policy(organization: organization, user: users.works_at_org_1_and_2).apply(:show?)
+
+      assert_equal false, policy(organization: organization, user: users.retired_staff).apply(:show?)
+      assert_equal false, policy(organization: organization, user: users.archived_organization_1_manager).apply(:show?)
+
+      assert_equal false, policy(organization: organization, user: users.organization_1_staff).apply(:show?)
+      assert_equal false, policy(organization: organization, user: users.organization_2_owner).apply(:show?)
+    end
+
+    test "manage?: only true when the user has an active organization_manager membership" do
+      organization = organizations.organization_1
+
+      assert_equal true, policy(organization: organization, user: users.organization_1_owner).apply(:manage?)
+      assert_equal true, policy(organization: organization, user: users.organization_1_manager).apply(:manage?)
+
+      assert_equal false, policy(organization: organization, user: users.works_at_org_1_and_2).apply(:manage?)
+      assert_equal false, policy(organization: organization, user: users.retired_staff).apply(:manage?)
+      assert_equal false, policy(organization: organization, user: users.archived_organization_1_manager).apply(:manage?)
+
+      assert_equal false, policy(organization: organization, user: users.organization_1_staff).apply(:manage?)
+      assert_equal false, policy(organization: organization, user: users.organization_2_owner).apply(:manage?)
+    end
+
+    test "remove_organization_manager?: only allowed if more than 1 organization_manager" do
+      organization_1 = organizations.organization_1
+      assert_equal true, policy_class.new(organization_1, user: users.organization_1_owner).apply(:remove_organization_manager?)
+      assert_equal false, policy_class.new(organizations.organization_2, user: users.organization_2_owner).apply(:remove_organization_manager?)
+
+      organization_1.memberships.where(user: users.organization_1_manager).delete_all
+
+      assert_equal false, policy_class.new(organization_1, user: users.organization_1_owner).apply(:remove_organization_manager?)
+    end
+  end
+end