/**
* Copyright (c) 2009--2014 Red Hat, Inc.
*
* This software is licensed to you under the GNU General Public License,
* version 2 (GPLv2). There is NO WARRANTY for this software, express or
* implied, including the implied warranties of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2
* along with this software; if not, see
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
*
* Red Hat trademarks are not licensed under GPLv2. No permission is
* granted to use or replicate Red Hat trademarks that are incorporated
* in this software or its documentation.
*/
package com.redhat.rhn.frontend.xmlrpc.errata.test;
import com.redhat.rhn.FaultException;
import com.redhat.rhn.common.db.datasource.DataResult;
import com.redhat.rhn.domain.channel.Channel;
import com.redhat.rhn.domain.channel.test.ChannelFactoryTest;
import com.redhat.rhn.domain.errata.Bug;
import com.redhat.rhn.domain.errata.Errata;
import com.redhat.rhn.domain.errata.ErrataFactory;
import com.redhat.rhn.domain.errata.Keyword;
import com.redhat.rhn.domain.errata.impl.PublishedBug;
import com.redhat.rhn.domain.errata.test.ErrataFactoryTest;
import com.redhat.rhn.domain.rhnpackage.Package;
import com.redhat.rhn.domain.rhnpackage.PackageEvr;
import com.redhat.rhn.domain.rhnpackage.PackageEvrFactory;
import com.redhat.rhn.domain.rhnpackage.test.PackageTest;
import com.redhat.rhn.domain.user.User;
import com.redhat.rhn.frontend.xmlrpc.InvalidAdvisoryReleaseException;
import com.redhat.rhn.frontend.xmlrpc.errata.ErrataHandler;
import com.redhat.rhn.frontend.xmlrpc.test.BaseHandlerTestCase;
import com.redhat.rhn.manager.errata.ErrataManager;
import com.redhat.rhn.testing.TestUtils;
import com.redhat.rhn.testing.UserTestUtils;
import org.apache.commons.lang.RandomStringUtils;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class ErrataHandlerTest extends BaseHandlerTestCase {
private ErrataHandler handler = new ErrataHandler();
private User user;
@Override
public void setUp() throws Exception {
// TODO Auto-generated method stub
super.setUp();
user = UserTestUtils.createUser("testUser", admin.getOrg().getId());
}
public void testGetDetails() throws Exception {
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
Errata check = ErrataManager.lookupErrata(errata.getId(), user);
assertTrue(check.getAdvisory().equals(errata.getAdvisory()));
assertTrue(check.getId().equals(errata.getId()));
Map details = handler.getDetails(admin, errata.getAdvisory());
assertNotNull(details);
try {
details = handler.getDetails(admin, "foo" + TestUtils.randomString());
fail("found invalid errata");
}
catch (FaultException e) {
//success
}
}
public void testSetDetailsAdvRelAboveMax() throws Exception {
// setup
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
Map<String, Object> details = new HashMap<String, Object>();
details.put("advisory_release", new Integer(10000));
try {
handler.setDetails(admin, errata.getAdvisory(), details);
fail("invalid advisory of 10000 accepted");
}
catch (InvalidAdvisoryReleaseException iare) {
// we expect this test to fail
assertTrue(true);
}
}
public void testSetDetails() throws Exception {
// setup
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
// execute
Map<String, Object> details = new HashMap<String, Object>();
details.put("synopsis", "synopsis-1");
details.put("advisory_name", "advisory-1");
details.put("advisory_release", 123);
details.put("advisory_type", "Security Advisory");
details.put("product", "product text");
details.put("topic", "topic text");
details.put("description", "description text");
details.put("references", "references text");
details.put("notes", "notes text");
details.put("solution", "solution text");
List<Map<String, Object>> bugs = new ArrayList<Map<String, Object>>();
Map<String, Object> bug1 = new HashMap<String, Object>();
bug1.put("id", 1);
bug1.put("summary", "bug1 summary");
bugs.add(bug1);
Map<String, Object> bug2 = new HashMap<String, Object>();
bug2.put("id", 2);
bug2.put("summary", "bug2 summary");
bugs.add(bug2);
details.put("bugs", bugs);
List<String> keywords = new ArrayList<String>();
keywords.add("keyword1");
keywords.add("keyword2");
details.put("keywords", keywords);
int result = handler.setDetails(admin, errata.getAdvisory(), details);
// verify
assertEquals(1, result);
Errata updatedErrata = ErrataManager.lookupErrata(errata.getId(), user);
assertEquals(errata.getSynopsis(), "synopsis-1");
assertEquals(errata.getAdvisory(), "advisory-1-123");
assertEquals(errata.getAdvisoryName(), "advisory-1");
assertEquals(errata.getAdvisoryRel(), new Long(123));
assertEquals(errata.getAdvisoryType(), "Security Advisory");
assertEquals(errata.getProduct(), "product text");
assertEquals(errata.getTopic(), "topic text");
assertEquals(errata.getDescription(), "description text");
assertEquals(errata.getRefersTo(), "references text");
assertEquals(errata.getNotes(), "notes text");
assertEquals(errata.getSolution(), "solution text");
boolean foundBug1 = false, foundBug2 = false;
for (Bug bug : (Set<Bug>) errata.getBugs()) {
if (bug.getId().equals(new Long(1)) &&
bug.getSummary().equals("bug1 summary")) {
foundBug1 = true;
}
if (bug.getId().equals(new Long(2)) &&
bug.getSummary().equals("bug2 summary")) {
foundBug2 = true;
}
}
assertTrue(foundBug1);
assertTrue(foundBug2);
boolean foundKeyword1 = false, foundKeyword2 = false;
for (Keyword keyword : errata.getKeywords()) {
if (keyword.getKeyword().equals("keyword1")) {
foundKeyword1 = true;
}
if (keyword.getKeyword().equals("keyword2")) {
foundKeyword2 = true;
}
}
assertTrue(foundKeyword1);
assertTrue(foundKeyword2);
}
public void testListAffectedSystems() throws Exception {
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
Errata check = ErrataManager.lookupErrata(errata.getId(), user);
assertTrue(check.getAdvisory().equals(errata.getAdvisory()));
assertTrue(check.getId().equals(errata.getId()));
Object[] systems = handler.listAffectedSystems(admin, errata.getAdvisory());
assertNotNull(systems);
assertTrue(systems.length == 0);
}
public void testBugzillaFixes() throws Exception {
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
Bug bug1 = new PublishedBug();
bug1.setId(new Long(1001));
bug1.setSummary("This is a test summary");
errata.addBug(bug1);
ErrataManager.storeErrata(errata);
int numBugs = errata.getBugs().size();
Map bugs = handler.bugzillaFixes(admin, errata.getAdvisory());
assertEquals(numBugs, bugs.size());
//map should contain an 'id' key only
Set keys = bugs.keySet();
assertEquals(1, keys.size());
assertEquals("This is a test summary", bugs.get(new Long(1001)));
}
public void testListKeywords() throws Exception {
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
errata.addKeyword("foo");
errata.addKeyword("bar");
ErrataManager.storeErrata(errata);
Object[] keywords = handler.listKeywords(admin, errata.getAdvisory());
assertEquals(errata.getKeywords().size(), keywords.length);
}
public void testApplicableToChannels() throws Exception {
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
DataResult dr = ErrataManager.applicableChannels(errata.getId(),
user.getOrg().getId(), null, Map.class);
Object[] channels = handler.applicableToChannels(admin, errata.getAdvisory());
assertEquals(dr.size(), channels.length);
}
public void testListCves() throws Exception {
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
DataResult dr = ErrataManager.errataCVEs(errata.getId());
List cves = handler.listCves(admin, errata.getAdvisory());
assertEquals(dr.size(), cves.size());
}
public void testPackages() throws Exception {
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
Package p = PackageTest.createTestPackage(user.getOrg());
errata.addPackage(p);
ErrataManager.storeErrata(errata);
List<Map> pkgs = handler.listPackages(admin, errata.getAdvisory());
assertNotNull(pkgs);
assertEquals(errata.getPackages().size(), pkgs.size());
assertTrue(pkgs.size() > 0);
boolean found = false;
for (Map pkg : pkgs) {
if (pkg.get("id").equals(p.getId())) {
found = true;
}
}
assertTrue(found);
}
public void testAddPackages() throws Exception {
// setup
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
ErrataManager.storeErrata(errata);
int initialNumPkgs = handler.listPackages(admin, errata.getAdvisory()).size();
Package pkg1 = PackageTest.createTestPackage(user.getOrg());
Package pkg2 = PackageTest.createTestPackage(user.getOrg());
// execute
List<Integer> pkgIds = new ArrayList<Integer>();
pkgIds.add(pkg1.getId().intValue());
pkgIds.add(pkg2.getId().intValue());
int numPkgsAdded = handler.addPackages(admin, errata.getAdvisory(), pkgIds);
// verify
assertEquals(2, numPkgsAdded);
int resultNumPkgs = handler.listPackages(admin, errata.getAdvisory()).size();
assertEquals(initialNumPkgs + 2, resultNumPkgs);
boolean found1 = false, found2 = false;
for (Package pkg : errata.getPackages()) {
if (pkg.getId().equals(pkg1.getId())) {
found1 = true;
}
if (pkg.getId().equals(pkg2.getId())) {
found2 = true;
}
}
assertTrue(found1);
assertTrue(found2);
}
public void testRemovePackages() throws Exception {
// setup
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
Package pkg1 = PackageTest.createTestPackage(user.getOrg());
Package pkg2 = PackageTest.createTestPackage(user.getOrg());
errata.addPackage(pkg1);
errata.addPackage(pkg2);
ErrataManager.storeErrata(errata);
int initialNumPkgs = handler.listPackages(admin, errata.getAdvisory()).size();
// execute
List<Integer> pkgIds = new ArrayList<Integer>();
pkgIds.add(pkg2.getId().intValue());
int numPkgsRemoved = handler.removePackages(admin, errata.getAdvisory(), pkgIds);
// verify
assertEquals(1, numPkgsRemoved);
int resultNumPkgs = handler.listPackages(admin, errata.getAdvisory()).size();
assertEquals(initialNumPkgs - 1, resultNumPkgs);
boolean found1 = false, found2 = false;
for (Package pkg : errata.getPackages()) {
if (pkg.getId().equals(pkg1.getId())) {
found1 = true;
}
if (pkg.getId().equals(pkg2.getId())) {
found2 = true;
}
}
assertTrue(found1);
assertFalse(found2);
}
public void testCloneErrata() throws Exception {
Channel channel = ChannelFactoryTest.createTestChannel(admin);
channel.setOrg(admin.getOrg());
Package errataPack = PackageTest.createTestPackage(admin.getOrg());
Package chanPack = PackageTest.createTestPackage(admin.getOrg());
//we have to set the 2nd package to a different EVR to not violate a
// unique constraint
PackageEvr evr = PackageEvrFactory.lookupOrCreatePackageEvr("45", "99", "983");
chanPack.setPackageName(errataPack.getPackageName());
chanPack.setPackageEvr(evr);
channel.addPackage(chanPack);
Errata toClone = ErrataFactoryTest.createTestPublishedErrata(
admin.getOrg().getId());
toClone.addPackage(errataPack);
ArrayList errata = new ArrayList();
errata.add(toClone.getAdvisory());
Object[] returnValue = handler.clone(admin,
channel.getLabel(), errata);
assertEquals(1, returnValue.length);
Errata cloned = ErrataFactory.lookupById(((Errata)returnValue[0]).getId());
assertNotSame(toClone.getId(), cloned.getId());
Set channels = cloned.getChannels();
assertEquals(1, channels.size());
Channel sameChannel = ((Channel)channels.toArray()[0]);
assertEquals(channel, sameChannel);
Set packs = sameChannel.getPackages();
assertEquals(packs.size(), 2);
assertTrue(packs.contains(errataPack));
assertTrue(packs.contains(chanPack));
}
public void testCreate() throws Exception {
Channel channel = ChannelFactoryTest.createBaseChannel(admin);
channel.setOrg(admin.getOrg());
Map errataInfo = new HashMap();
String advisoryName = TestUtils.randomString();
populateErrataInfo(errataInfo);
errataInfo.put("advisory_name", advisoryName);
ArrayList packages = new ArrayList();
ArrayList bugs = new ArrayList();
ArrayList keywords = new ArrayList();
ArrayList channels = new ArrayList();
channels.add(channel.getLabel());
Errata errata = handler.create(admin, errataInfo,
bugs, keywords, packages, true, channels);
Errata result = ErrataFactory.lookupByAdvisory(advisoryName);
assertEquals(errata, result);
assertEquals(advisoryName + "-" + errata.getAdvisoryRel().toString(),
result.getAdvisory());
}
public void testDelete() throws Exception {
Errata errata = ErrataFactoryTest.createTestErrata(user.getOrg().getId());
Errata check = ErrataManager.lookupErrata(errata.getId(), user);
assertTrue(check.getAdvisory().equals(errata.getAdvisory()));
assertTrue(check.getId().equals(errata.getId()));
// delete a published erratum
int result = handler.delete(admin, errata.getAdvisory());
assertEquals(1, result);
errata = (Errata) TestUtils.reload(errata);
assertNull(errata);
errata = ErrataFactoryTest.createTestUnpublishedErrata(user.getOrg().getId());
check = ErrataManager.lookupErrata(errata.getId(), user);
assertTrue(check.getAdvisory().equals(errata.getAdvisory()));
assertTrue(check.getId().equals(errata.getId()));
// delete an unpublished erratum
result = handler.delete(admin, errata.getAdvisory());
assertEquals(1, result);
errata = (Errata) TestUtils.reload(errata);
assertNull(errata);
}
private void populateErrataInfo(Map errataInfo) {
errataInfo.put("synopsis", TestUtils.randomString());
errataInfo.put("advisory_release", new Integer(2));
errataInfo.put("advisory_type", "Bug Fix Advisory");
errataInfo.put("product", TestUtils.randomString());
errataInfo.put("topic", TestUtils.randomString());
errataInfo.put("description", TestUtils.randomString());
errataInfo.put("solution", TestUtils.randomString());
errataInfo.put("references", TestUtils.randomString());
errataInfo.put("notes", TestUtils.randomString());
}
public void testAdvisoryLength() throws Exception {
Channel channel = ChannelFactoryTest.createBaseChannel(admin);
Map errataInfo = new HashMap();
String advisoryName = RandomStringUtils.randomAscii(101);
populateErrataInfo(errataInfo);
errataInfo.put("advisory_name", advisoryName);
ArrayList packages = new ArrayList();
ArrayList bugs = new ArrayList();
ArrayList keywords = new ArrayList();
ArrayList channels = new ArrayList();
channels.add(channel.getLabel());
try {
Errata errata = handler.create(admin, errataInfo,
bugs, keywords, packages, true, channels);
fail("large advisory name was accepted");
}
catch (Exception e) {
// we expect this to fail
assertTrue(true);
}
}
public void testAdvisoryReleaseAboveMax() throws Exception {
Channel channel = ChannelFactoryTest.createBaseChannel(admin);
channel.setOrg(admin.getOrg());
Map errataInfo = new HashMap();
String advisoryName = TestUtils.randomString();
populateErrataInfo(errataInfo);
errataInfo.put("advisory_name", advisoryName);
errataInfo.put("advisory_release", new Integer(10000));
ArrayList packages = new ArrayList();
ArrayList bugs = new ArrayList();
ArrayList keywords = new ArrayList();
ArrayList channels = new ArrayList();
channels.add(channel.getLabel());
try {
Errata errata = handler.create(admin, errataInfo,
bugs, keywords, packages, true, channels);
fail("large advisory release was accepted");
}
catch (InvalidAdvisoryReleaseException iare) {
// we expect this to fail
assertTrue(true);
}
}
public void testAdvisoryReleaseAtMax() throws Exception {
Channel channel = ChannelFactoryTest.createBaseChannel(admin);
channel.setOrg(admin.getOrg());
Map errataInfo = new HashMap();
String advisoryName = TestUtils.randomString();
populateErrataInfo(errataInfo);
errataInfo.put("advisory_name", advisoryName);
errataInfo.put("advisory_release", new Integer(9999));
ArrayList packages = new ArrayList();
ArrayList bugs = new ArrayList();
ArrayList keywords = new ArrayList();
ArrayList channels = new ArrayList();
channels.add(channel.getLabel());
Errata errata = handler.create(admin, errataInfo,
bugs, keywords, packages, true, channels);
assertEquals(ErrataManager.MAX_ADVISORY_RELEASE,
errata.getAdvisoryRel().longValue());
}
public void testPublish() throws Exception {
Errata unpublished = ErrataFactoryTest.createTestUnpublishedErrata(
admin.getOrg().getId());
Channel channel = ChannelFactoryTest.createBaseChannel(admin);
channel.setOrg(admin.getOrg());
ArrayList channels = new ArrayList();
channels.add(channel.getLabel());
Errata published = handler.publish(admin, unpublished.getAdvisoryName(),
channels);
assertTrue(published.isPublished());
assertEquals(unpublished.getAdvisory(), published.getAdvisory());
}
public void testListByDate() throws Exception {
Calendar cal = Calendar.getInstance();
Date earlyDate = cal.getTime();
cal.add(Calendar.YEAR, 5);
Date laterDate = cal.getTime();
assertTrue(earlyDate.before(laterDate));
Errata earlyErrata = ErrataFactoryTest.createTestPublishedErrata(
admin.getOrg().getId());
Errata laterErrata = ErrataFactoryTest.createTestPublishedErrata(
admin.getOrg().getId());
Channel testChannel = ChannelFactoryTest.createTestChannel(admin);
earlyErrata.addChannel(testChannel);
earlyErrata.setIssueDate(earlyDate);
laterErrata.addChannel(testChannel);
laterErrata.setIssueDate(laterDate);
List test = handler.listByDate(admin, testChannel.getLabel());
assertEquals(2, test.size());
Object[] array = test.toArray();
assertEquals(array[0], earlyErrata);
assertEquals(array[1], laterErrata);
}
}