Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.cs;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.CustomRetailer;

import com.spice.profitmandi.dao.entity.cs.DemoPartnerAccess;

import com.spice.profitmandi.dao.repository.cs.CsService;

import com.spice.profitmandi.dao.repository.cs.DemoPartnerAccessRepository;

import com.spice.profitmandi.dao.repository.cs.DemoPartnerAccessService;

import com.spice.profitmandi.service.AdminUser;

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.web.config.AppConfig;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.junit.Assert;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.annotation.Rollback;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import org.springframework.test.context.web.WebAppConfiguration;

import org.springframework.transaction.annotation.Transactional;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.Map;

/**

 * Local-database integration tests (rolled back) for demo partner access: a grant opens the partner

 * for the sales person without ever entering the shared position mapping.

 */

@RunWith(SpringJUnit4ClassRunner.class)

@WebAppConfiguration

@ContextConfiguration(classes = {AppConfig.class})

@Transactional

public class DemoPartnerAccessTest {

    private static final int GRANTOR = 1;

    @Autowired private DemoPartnerAccessService demoPartnerAccessService;

    @Autowired private DemoPartnerAccessRepository demoPartnerAccessRepository;

    @Autowired private CsService csService;

    @Autowired private RetailerService retailerService;

    @Autowired private SessionFactory sessionFactory;

    @Test

    @Rollback

    public void grantAllowsPartnerWithoutTouchingPositionMapping() throws Exception {

        int salesUser = this.anySalesUser();

        int fofoId = this.anyActiveStoreNotMappedTo(salesUser);

        Assert.assertFalse(demoPartnerAccessService.isAllowed(salesUser, fofoId));

        Map<String, Object> result = demoPartnerAccessService.grant(GRANTOR, salesUser, Collections.singletonList(fofoId));

        this.session().flush();

        Assert.assertEquals(1, result.get("granted"));

        Assert.assertTrue(demoPartnerAccessService.isAllowed(salesUser, fofoId));

        Assert.assertTrue(demoPartnerAccessService.getDemoFofoIds(salesUser).contains(fofoId));

        List<Integer> positionFofoIds = csService.getAuthUserIdPartnerIdMapping().get(salesUser);

        Assert.assertTrue("demo partner must not leak into the position mapping",

                positionFofoIds == null || !positionFofoIds.contains(fofoId));

        CustomRetailer retailer = retailerService.getFofoRetailer(fofoId);

        Assert.assertTrue(demoPartnerAccessService.getDemoPartnerEmails(salesUser).contains(retailer.getEmail()));

        DemoPartnerAccess grant = demoPartnerAccessRepository.selectActive(salesUser, fofoId);

        demoPartnerAccessService.revoke(GRANTOR, grant.getId());

        this.session().flush();

        Assert.assertFalse(demoPartnerAccessService.isAllowed(salesUser, fofoId));

        Assert.assertNull(demoPartnerAccessRepository.selectActive(salesUser, fofoId));

    }

    @Test

    @Rollback

    public void grantSkipsDuplicateAndPositionMappedPartners() throws Exception {

        int salesUser = this.anySalesUser();

        int fofoId = this.anyActiveStoreNotMappedTo(salesUser);

        demoPartnerAccessService.grant(GRANTOR, salesUser, Collections.singletonList(fofoId));

        this.session().flush();

        List<Integer> positionFofoIds = csService.getAuthUserIdPartnerIdMapping().get(salesUser);

        List<Integer> request = positionFofoIds == null || positionFofoIds.isEmpty()

                ? Collections.singletonList(fofoId) : Arrays.asList(fofoId, positionFofoIds.get(0));

        Map<String, Object> result = demoPartnerAccessService.grant(GRANTOR, salesUser, request);

        Assert.assertEquals(0, result.get("granted"));

        Assert.assertEquals(request.size(), ((List<?>) result.get("skipped")).size());

    }

    @Test(expected = ProfitMandiBusinessException.class)

    @Rollback

    public void grantRejectsNonSalesUser() throws Exception {

        int nonSales = ((Number) this.session().createNativeQuery(

                "SELECT u.id FROM auth.auth_user u WHERE u.active = 1 AND u.id NOT IN "

                        + "(SELECT auth_user_id FROM cs.position WHERE category_id = 4) LIMIT 1").getSingleResult()).intValue();

        demoPartnerAccessService.grant(GRANTOR, nonSales, Collections.singletonList(this.anyActiveStoreNotMappedTo(nonSales)));

    }

    @Test

    @Rollback

    public void salesUserCannotManageGrants() {

        Assert.assertFalse(demoPartnerAccessService.canManage(this.anySalesUser()));

    }

    @Test

    @Rollback

    public void revokingTwiceFails() throws Exception {

        int salesUser = this.anySalesUser();

        int fofoId = this.anyActiveStoreNotMappedTo(salesUser);

        demoPartnerAccessService.grant(GRANTOR, salesUser, Collections.singletonList(fofoId));

        this.session().flush();

        int id = demoPartnerAccessRepository.selectActive(salesUser, fofoId).getId();

        demoPartnerAccessService.revoke(GRANTOR, id);

        this.session().flush();

        try {

            demoPartnerAccessService.revoke(GRANTOR, id);

            Assert.fail("second revoke must fail");

        } catch (ProfitMandiBusinessException expected) {

        }

    }

    // Active Sales user who cannot see every menu (no L5 position, not an all-menu email, not Business Intelligence).

    private int anySalesUser() {

        return ((Number) this.session().createNativeQuery(

                "SELECT p.auth_user_id FROM cs.position p JOIN auth.auth_user u ON u.id = p.auth_user_id "

                        + "WHERE p.category_id = 4 AND u.active = 1 AND u.email_id NOT IN (:emails) AND p.auth_user_id NOT IN "

                        + "(SELECT auth_user_id FROM cs.position WHERE escalation_type = 'L5' OR category_id = 19) "

                        + "ORDER BY p.auth_user_id LIMIT 1")

                .setParameter("emails", AdminUser.ALL_MENU_EMAILS).getSingleResult()).intValue();

    }

    private int anyActiveStoreNotMappedTo(int authUserId) throws Exception {

        List<Integer> mapped = csService.getAuthUserIdPartnerIdMapping().get(authUserId);

        List<?> ids = this.session().createNativeQuery(

                "SELECT fs.id FROM fofo.fofo_store fs WHERE fs.active = 1 AND fs.internal = 0 ORDER BY fs.id").getResultList();

        for (Object id : ids) {

            int fofoId = ((Number) id).intValue();

            if (mapped == null || !mapped.contains(fofoId)) {

                return fofoId;

            }

        }

        throw new IllegalStateException("No unmapped active store");

    }

    private Session session() {

        return sessionFactory.getCurrentSession();

    }

}