def test_ignore_defects():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
create_defect_type(ddb, 2)
ddb.insert("DQD_TEST_DEFECT_0", 0, 100, "", "")
ddb.insert("DQD_TEST_DEFECT_1", 100, 200, "", "")
ddb.insert("DQD_TEST_DEFECT_2", 200, 300, "", "")
ddb.new_virtual_defect(
"DQD_TEST_VIRTUAL_DEFECT", "",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1 DQD_TEST_DEFECT_2")
ignored_defects = set(["DQD_TEST_DEFECT_1"])
iovs = ddb.retrieve()
assert iov_result_depends(iovs) & ignored_defects, "test is broken"
iovs = ddb.retrieve(ignore=ignored_defects)
assert not iov_result_depends(
iovs) & ignored_defects, "result depends on ignored defects"
def test_independent_tags():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
create_defect_type(ddb, 2)
ddb.insert("DQD_TEST_DEFECT_0", 0, 100, "", "")
ddb.insert("DQD_TEST_DEFECT_1", 100, 200, "", "")
ddb.insert("DQD_TEST_DEFECT_2", 200, 300, "", "")
dtag1 = ddb.new_defects_tag("dqd-test", "New iov tag")
ddb.insert("DQD_TEST_DEFECT_0", 0, 100, "", "", present=False)
dtag2 = ddb.new_defects_tag("dqd-test-2", "New iov tag")
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT", "",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
ltag1 = ddb.new_logics_tag()
ddb.update_virtual_defect("DQD_TEST_VIRTUAL_DEFECT",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_2")
ltag2 = ddb.new_logics_tag()
iovs = DefectsDB(
TEST_DATABASE,
tag=("HEAD", ltag1)).retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
assert iov_ranges(iovs) == [(100, 200)], str(iov_ranges(iovs))
iovs = DefectsDB(
TEST_DATABASE,
tag=("HEAD", ltag2)).retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
assert iov_ranges(iovs) == [(200, 300)], str(iov_ranges(iovs))
iovs = DefectsDB(
TEST_DATABASE,
tag=(dtag1, ltag1)).retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
assert iov_ranges(iovs) == [(0, 100), (100, 200)], str(iov_ranges(iovs))
iovs = DefectsDB(
TEST_DATABASE,
tag=(dtag2, ltag2)).retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
assert iov_ranges(iovs) == [(200, 300)], str(iov_ranges(iovs))
htag = ddb.new_hierarchical_tag(dtag2, ltag2)
iovs = DefectsDB(TEST_DATABASE,
tag=(htag,
htag)).retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
assert iov_ranges(iovs) == [(200, 300)], str(iov_ranges(iovs))
iovs = DefectsDB(TEST_DATABASE,
tag=htag).retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
assert iov_ranges(iovs) == [(200, 300)], str(iov_ranges(iovs))
def test_query_with_primary_dependencies_with_ignore():
"""
Checking with_primary_dependencies + ignore
Checks that the set of channels and iovs returned contains the correct
number of channels and iovs when specifying both with_primary_dependencies
and ignore to DQDefects.Retrieve
"""
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
defect_names = [create_defect_type(ddb, i) for i in range(3)]
for i, defect in enumerate(defect_names):
ddb.insert(defect, i * 100, (i + 1) * 100, "", "")
ignored = set(defect_names[:1])
ddb.new_virtual_defect("DQD_TEST_VDEFECT", "", " ".join(defect_names))
iovs = ddb.retrieve(channels=["DQD_TEST_VDEFECT"], ignore=ignored)
assert iovs.channels == set(["DQD_TEST_VDEFECT"])
assert len(iovs) == len(defect_names) - 1
iovs = ddb.retrieve(channels=["DQD_TEST_VDEFECT"],
ignore=ignored,
with_primary_dependencies=True)
assert iovs.channels == set(["DQD_TEST_VDEFECT"] +
defect_names) - ignored, ("Check failed.")
assert len(iovs) == len(defect_names[1:]) * 2
def test_noncontiguous_defectid_creation():
"""
Test that defects are inserted correctly into non-contiguous ranges
"""
ddb = DefectsDB(TEST_DATABASE, read_only=False)
create_defect_type(ddb, 0)
ddb._create_defect_with_id(2, "TEST_DEFECT_DQD_2", "")
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT", "Comment",
"DQD_TEST_DEFECT_0 TEST_DEFECT_DQD_2")
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT_2", "Comment",
"DQD_TEST_DEFECT_0 TEST_DEFECT_DQD_2")
create_defect_type(ddb, 1)
create_defect_type(ddb, 3)
# assert primary and virtual defects are right
ids, names, m = ddb.get_channels()
assert m == {
0: 'DQD_TEST_DEFECT_0',
1: 'DQD_TEST_DEFECT_1',
2: 'TEST_DEFECT_DQD_2',
3: 'DQD_TEST_DEFECT_3',
'DQD_TEST_DEFECT_3': 3,
'DQD_TEST_DEFECT_0': 0,
'DQD_TEST_DEFECT_1': 1,
'TEST_DEFECT_DQD_2': 2
}, 'Primary defect problem'
ids, names, m = ddb.get_virtual_channels()
assert m == {
2147483648: 'DQD_TEST_VIRTUAL_DEFECT',
2147483649: 'DQD_TEST_VIRTUAL_DEFECT_2',
'DQD_TEST_VIRTUAL_DEFECT': 2147483648,
'DQD_TEST_VIRTUAL_DEFECT_2': 2147483649
}, 'Virtual defect problem'
def test_tagging_unicode():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
ddb.insert(u"DQD_TEST_DEFECT_0", 0, 100, u"", u"")
ddb.insert(u"DQD_TEST_DEFECT_1", 100, 200, u"", u"")
defects_tag = ddb.new_defects_tag("dqd-test", u"New iov tag")
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect(u"DQD_TEST_VIRTUAL_DEFECT", u"",
u"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
original_tag = ddb.new_logics_tag()
original_htag = ddb.new_hierarchical_tag(defects_tag, original_tag)
what = {"channels": [u"DQD_TEST_VIRTUAL_DEFECT"]}
orig_iovs = DefectsDB((TEST_DATABASE),
tag=six.ensure_text(original_htag)).retrieve(**what)
assert len(orig_iovs) == 2
assert (orig_iovs[0].since, orig_iovs[0].until) == (0, 100)
assert (orig_iovs[1].since, orig_iovs[1].until) == (100, 200)
def test_many_sparse_channels():
"Testing many virtual channels with sparsely placed IoVs"
ddb = DefectsDB(TEST_DATABASE, read_only=False)
all_defects = []
for i in range(52):
all_defects.append(create_defect_type(ddb, i * 2))
with ddb.storage_buffer:
for i in all_defects:
ddb.insert(i, 0, 100, "Test", "DQDefects.tests")
queried_defects = all_defects[:-1]
result = ddb.retrieve(channels=queried_defects)
queried_defects_set = set(queried_defects)
result_defects_set = set(i.channel for i in result)
unwanted_defects_set = result_defects_set - queried_defects_set
assert not unwanted_defects_set, "Unwanted defects: %r" % unwanted_defects_set
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT", "Comment",
" ".join(all_defects))
result = ddb.retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
assert result.channels == set(["DQD_TEST_VIRTUAL_DEFECT"])
assert len(result) == 1
# This assumes evaluate_full == True
assert result[0].comment == " ".join(
sorted(all_defects)), result[0].comment
result = ddb.retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"],
evaluate_full=False)
assert result.channels == set(["DQD_TEST_VIRTUAL_DEFECT"])
assert len(result) == 1
def test_virtual_defects_invert():
"Testing virtual defects involving inversion"
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
create_defect_type(ddb, 2)
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect(
"DQD_TEST_VIRTUAL_DEFECT", "Comment",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1 !DQD_TEST_DEFECT_2")
# Insert an iov into each
ddb.insert("DQD_TEST_DEFECT_0", 0, 100, "Test", "DQDefects.tests")
ddb.insert("DQD_TEST_DEFECT_1", 150, 200, "Test", "DQDefects.tests")
ddb.insert("DQD_TEST_DEFECT_2", 50, 125, "Test", "DQDefects.tests")
# See what the result of the virtual defect is
iovs = ddb.retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
# Tests against the value
assert len(iovs) == 4, list(iovs)
first, second, third, fourth = iovs
assert (first.since, first.until) == (0, 50), first
assert (second.since, second.until) == (50, 100), second
assert (third.since, third.until) == (125, 150), third
assert (fourth.since, fourth.until) == (150, 200), fourth
assert first.channel == second.channel == third.channel == fourth.channel == "DQD_TEST_VIRTUAL_DEFECT", (
first.channel, second.channel, third.channel, fourth.channel)
del first, second, third, fourth, iovs
# Test evaluate_full=False
iovs = ddb.retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"],
evaluate_full=False)
assert len(iovs) == 2, list(iovs)
# Now unset the present bit
ddb.insert("DQD_TEST_DEFECT_2",
50,
150,
"Test",
"DQDefects.tests",
present=False)
iovs = ddb.retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
# here we are sensitive to details of python ordering ...
assert len(iovs) == 3, list(iovs)
first, second, third = iovs
assert (first.since, first.until) == (0, 100), first
assert (second.since, second.until) == (100, 150), second
assert (third.since, third.until) == (150, 200), third
assert first.channel == second.channel == third.channel == "DQD_TEST_VIRTUAL_DEFECT", (
first.channel, second.channel, third.channel)
del first, second, third, iovs
def test_virtual_defects():
"Testing virtual defect basics"
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT", "Comment",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
# Insert an iov into each
ddb.insert("DQD_TEST_DEFECT_0", 0, 100, "Test", "DQDefects.tests")
ddb.insert("DQD_TEST_DEFECT_1", 150, 200, "Test", "DQDefects.tests")
# See what the result of the virtual defect is
iovs = ddb.retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
# Tests against the value
assert len(iovs) == 2
first, second = iovs
assert (first.since, first.until) == (0, 100)
assert (second.since, second.until) == (150, 200)
assert first.channel == second.channel == "DQD_TEST_VIRTUAL_DEFECT"
del first, second, iovs
# Now unset the present bit, and test again that the relevant preiod is fixed
ddb.insert("DQD_TEST_DEFECT_1",
150,
200,
"Test",
"DQDefects.tests",
present=False)
iovs = ddb.retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
assert len(iovs) == 1
first = iovs[0]
assert (first.since, first.until) == (0, 100)
assert first.channel == "DQD_TEST_VIRTUAL_DEFECT"
# Now extend the defect and see if we get a contiguous result
ddb.insert("DQD_TEST_DEFECT_0", 100, 150, "Test", "DQDefects.tests")
iovs = ddb.retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
assert len(iovs) == 1
first = iovs[0]
assert (first.since, first.until) == (0, 150)
assert first.channel == "DQD_TEST_VIRTUAL_DEFECT"
def test_get_intolerable_defects():
'''
Check that the intolerable defect listing function works
'''
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create some primary defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
create_defect_type(ddb, 2)
create_defect_type(ddb, 3)
# Make some virtual defects
ddb.new_virtual_defect("DQD_TEST_Virtual_DEFECT", "Comment",
"DQD_TEST_DEFECT_0")
ddb.new_virtual_defect("PRIMARY", "Comment",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
ddb.new_virtual_defect("PHYS_test", "Comment",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1 DQD_TEST_DEFECT_2")
ddb.new_virtual_defect("TIGHT", "Comment",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1 DQD_TEST_DEFECT_2 DQD_TEST_DEFECT_3")
# old_primary_only should be True here, so PRIMARY gives the set of defects
assert sorted(ddb.get_intolerable_defects()) == ["DQD_TEST_DEFECT_0", "DQD_TEST_DEFECT_1"], "default params/old_primary_only check failed"
assert sorted(ddb.get_intolerable_defects(old_primary_only=False, exclude=['TIGHT'])) == ["DQD_TEST_DEFECT_0", "DQD_TEST_DEFECT_1", "DQD_TEST_DEFECT_2"], 'old_primary_only=False check failed'
assert sorted(ddb.get_intolerable_defects(old_primary_only=False)) == ["DQD_TEST_DEFECT_0", "DQD_TEST_DEFECT_1"], 'regex handling check failed'
def test_defect_empty_retrieval():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
iovs = ddb.retrieve()
assert not iovs
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT", "Comment",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
iovs = ddb.retrieve()
assert not iovs
def test_update_virtual_defect():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
create_defect_type(ddb, 2)
ddb.insert("DQD_TEST_DEFECT_0", 0, 100, "", "")
ddb.insert("DQD_TEST_DEFECT_1", 100, 200, "", "")
ddb.insert("DQD_TEST_DEFECT_2", 200, 300, "", "")
defects_tag = ddb.new_defects_tag("dqd-test", "New iov tag")
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT", "",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
original_tag = ddb.new_logics_tag()
original_htag = ddb.new_hierarchical_tag(defects_tag, original_tag)
ddb.update_virtual_defect("DQD_TEST_VIRTUAL_DEFECT",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_2")
new_tag = ddb.new_logics_tag()
new_htag = ddb.new_hierarchical_tag(defects_tag, new_tag)
what = {"channels": ["DQD_TEST_VIRTUAL_DEFECT"]}
orig_iovs = DefectsDB(TEST_DATABASE, tag=original_htag).retrieve(**what)
new_iovs = DefectsDB(TEST_DATABASE, tag=new_htag).retrieve(**what)
head_iovs = DefectsDB(TEST_DATABASE).retrieve(**what)
assert head_iovs == new_iovs
assert head_iovs != orig_iovs
assert len(head_iovs) == 2
assert (head_iovs[0].since, head_iovs[0].until) == (0, 100)
assert (head_iovs[1].since, head_iovs[1].until) == (200, 300)
from DQUtils.db import Databases
db3 = Databases.get_instance(TEST_DATABASE, read_only=True)
pfs = db3.getFolderSet('/GLOBAL/DETSTATUS')
assert pfs.tagDescription(
new_htag) != '', 'Hierarchical tag description not created'
def test_rename_defects():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
ddb.insert("DQD_TEST_DEFECT_0", 0, 100, "", "")
ddb.insert("DQD_TEST_DEFECT_1", 100, 200, "", "")
defects_tag = ddb.new_defects_tag("dqd-test", "New iov tag")
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT", "",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT_2", "",
"DQD_TEST_VIRTUAL_DEFECT")
# Make ones with inversion logic
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT_3", "",
"DQD_TEST_DEFECT_0 !DQD_TEST_DEFECT_1")
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT_4", "",
"!DQD_TEST_VIRTUAL_DEFECT")
original_tag = ddb.new_logics_tag()
original_htag = ddb.new_hierarchical_tag(defects_tag, original_tag)
# The following is no longer considered an error condition
## exc_raised = False
## try:
## ddb.rename_defect("DQD_TEST_DEFECT_0", "DQD_TEST_0")
## except AssertionError:
## exc_raised = True
## assert exc_raised, "Bad defect rename did not raise exception"
# first rename a primary defect
ddb.rename_defect("DQD_TEST_DEFECT_0", "DQD_TEST_DEFECT_3")
assert ddb.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT'].clauses == ['DQD_TEST_DEFECT_3', 'DQD_TEST_DEFECT_1'], ddb.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT'].clauses
assert ddb.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT_3'].clauses == ['DQD_TEST_DEFECT_3', '!DQD_TEST_DEFECT_1'], ddb.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT_3'].clauses
# also valid in other tags?
ddb2 = DefectsDB(TEST_DATABASE, tag=original_htag)
assert ddb2.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT'].clauses == ['DQD_TEST_DEFECT_3', 'DQD_TEST_DEFECT_1'], ddb2.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT'].clauses
# Now try to rename a virtual defect
ddb.rename_defect("DQD_TEST_VIRTUAL_DEFECT", "DQD_TEST_VIRTUAL_DEFECT_A")
assert ddb.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT_2'].clauses == ['DQD_TEST_VIRTUAL_DEFECT_A'], ddb.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT_2'].clauses
assert ddb.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT_4'].clauses == ['!DQD_TEST_VIRTUAL_DEFECT_A'], ddb.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT_4'].clauses
# also valid in other tags?
ddb2 = DefectsDB(TEST_DATABASE, tag=original_htag)
assert ddb2.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT_2'].clauses == ['DQD_TEST_VIRTUAL_DEFECT_A'], ddb2.virtual_defect_logics['DQD_TEST_VIRTUAL_DEFECT_2'].clauses
ddb._virtual_defect_consistency_check()
def test_virtual_defects_deep():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
# Insert an iov into each
ddb.insert("DQD_TEST_DEFECT_0", 0, 100, "Test", "DQDefects.tests")
ddb.insert("DQD_TEST_DEFECT_1", 150, 200, "Test", "DQDefects.tests")
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT_0", "", "DQD_TEST_DEFECT_0")
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT_1", "", "DQD_TEST_DEFECT_1")
ddb = DefectsDB(TEST_DATABASE)
iovs = ddb.retrieve()
def test_virtual_defect_hiding():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT", "Comment",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
new_tag = ddb.new_logics_tag()
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT_2", "Comment",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
ddb2 = DefectsDB(TEST_DATABASE, tag=('HEAD', new_tag), read_only=True)
assert ddb2.virtual_defect_names == set(['DQD_TEST_VIRTUAL_DEFECT']), 'Only one virtual defect should be in this tag'
def test_normalize_defect_names():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect("DQD_TEST_Virtual_DEFECT", "Comment",
"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
assert ddb.normalize_defect_names('dQd_tEsT_DeFeCt_0')=='DQD_TEST_DEFECT_0'
assert ddb.normalize_defect_names(['dQd_tEsT_DeFeCt_0', 'DqD_TeSt_dEfEcT_1'])==['DQD_TEST_DEFECT_0', 'DQD_TEST_DEFECT_1']
assert ddb.normalize_defect_names('dqd_test_virtual_defect')=='DQD_TEST_Virtual_DEFECT'
try:
ddb.normalize_defect_names('does_not_exist')
wasthrown = False
except DefectUnknownError:
wasthrown = True
assert wasthrown, 'normalize_defect_names should throw when the defect does not exist'
def test_virtual_defect_creation_unicode():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
create_defect_type(ddb, 0)
create_defect_type(ddb, 1)
# Make a virtual defect whose result is the combination of the above
ddb.new_virtual_defect(u"DQD_TEST_VIRTUAL_DEFECT", u"Comment",
u"DQD_TEST_DEFECT_0 DQD_TEST_DEFECT_1")
# First test ensures internals are correct
assert len(ddb.virtual_defect_ids) == 1
assert "DQD_TEST_VIRTUAL_DEFECT" in ddb.virtual_defect_names
# Second test to ensure database is in correct state
ddb = DefectsDB(TEST_DATABASE)
assert len(ddb.virtual_defect_ids) == 1
assert "DQD_TEST_VIRTUAL_DEFECT" in ddb.virtual_defect_names
def test_virtual_defects_stress():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
STRESS_COUNT = 20
for i in range(STRESS_COUNT):
create_defect_type(ddb, i)
with ddb.storage_buffer:
for i in range(STRESS_COUNT):
ddb.insert("DQD_TEST_DEFECT_%i" % i, i, i + 1, "Test",
"DQDefects.tests")
ALL_DEFECTS = " ".join("DQD_TEST_DEFECT_%i" % i
for i in range(STRESS_COUNT))
ddb.new_virtual_defect("DQD_TEST_VIRTUAL_DEFECT", "", ALL_DEFECTS)
iovs = ddb.retrieve(channels=["DQD_TEST_VIRTUAL_DEFECT"])
assert len(iovs) == STRESS_COUNT - 1
assert (iovs[0].since, iovs[-1].until) == (1, STRESS_COUNT)
def test_query_with_primary_dependencies():
ddb = DefectsDB(TEST_DATABASE, read_only=False)
# Create two defects
defect_names = [create_defect_type(ddb, i) for i in range(3)]
for i, defect in enumerate(defect_names):
ddb.insert(defect, i * 100, (i + 1) * 100, "", "")
ddb.new_virtual_defect("DQD_TEST_VDEFECT", "", " ".join(defect_names))
iovs = ddb.retrieve(channels=["DQD_TEST_VDEFECT"])
assert iovs.channels == set(["DQD_TEST_VDEFECT"])
assert len(iovs) == len(defect_names)
iovs = ddb.retrieve(channels=["DQD_TEST_VDEFECT"],
with_primary_dependencies=True)
assert iovs.channels == set(["DQD_TEST_VDEFECT"] +
defect_names), ("Check failed.")
assert len(iovs) == len(defect_names) * 2
print 'Reading in definitions...'
inclauses = indb.virtual_defect_logics
print '%d virtual defects retrieved from input database' % len(inclauses)
inchannels = set(channels if channels is not None else inclauses.keys())
outchannels = set(outdb.virtual_defect_names)
missingchannels = inchannels - outchannels
with outdb.storage_buffer:
if len(missingchannels) != 0:
if not opts.createdefects:
print 'Missing virtual defect(s) in target database:'
print list(missingchannels)
print 'Rerun with a restricted virtual defect list (--defects) or with --createdefects'
sys.exit(1)
else:
print 'Creating missing virtual defects on output database...'
descriptions = indb.get_virtual_channel_descriptions(
missingchannels)
for channel in missingchannels:
outdb.new_virtual_defect(
channel, descriptions[channel],
' '.join(inclauses[channel].clauses))
print 'Done'
print 'Updating existing virtual defects...'
for channel in inchannels - missingchannels:
outdb.update_virtual_defect(channel,
' '.join(inclauses[channel].clauses))
print 'Done.'
print 'ERROR: Problem parsing file', f
print str(e)
sys.exit(1)
if not tmp_indict:
print 'NOTICE: No definitions in file', f
continue
interset = set(tmp_indict) & set(indict)
if len(interset) > 0:
for k in interset:
print 'WARNING: Redefinition of defect', k, 'in file', f
if not opts.ignore_redef:
sys.exit(1)
indict.update(tmp_indict)
#print '\n'.join(map(str,tocreate))
from DQDefects import DefectsDB
from DQDefects.exceptions import DefectUnknownError
ddb = DefectsDB(opts.db, create=opts.create, read_only=False,
tag=opts.tag)
print 'Now updating defects on', opts.db
with ddb.storage_buffer:
for defect, clause in indict.items():
print defect, clause
try:
ddb.update_virtual_defect(defect, ' '.join(clause))
except DefectUnknownError:
ddb.new_virtual_defect(defect, '', ' '.join(clause))
#print 'ERROR: defect', defect, 'not present in DB, unable to update'
#sys.exit(1)
## try:
## print db.new_virtual_defect(0, defect, defect, ''), defect
## except DefectExistsError:
## if opts.ignoreold:
## print 'Defect', defect, 'already exists; ignoring'
## else:
## raise
folder = Databases.get_folder(opts.origpridb, read_only=True)
ids, names, cdict = get_channel_ids_names(folder)
for defect in names:
if defect in DEPRECATED_PRIMARY_FLAGS:
print 'Skipping', defect, 'as it is deprecated'
continue
#print defect, folder.channelDescription(cdict[defect])
try:
print db.new_virtual_defect(defect, defect, ''), defect
except DefectExistsError:
if opts.ignoreold:
print 'Defect', defect, 'already exists; ignoring'
else:
raise
print 'Populating old virtual flags'
folder = Databases.get_folder(opts.origvfdb, read_only=True)
ids, names, cdict = get_channel_ids_names(folder)
iovs = fetch_iovs(opts.origvfdb, (opts.vfrun, 1), (opts.vfrun, 2),
tag=opts.vftag,
with_channel=True)
for defect in iovs:
