def test_custom_counts(self, fixture_working_dir_env_repo_scoped,
snapshot):
"""Test getting the a LabBook's package manager dependencies"""
# Create labbook
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
lb.new(owner={"username": "******"},
name="labbook55",
description="my first labbook10000")
cm = ComponentManager(lb)
# Add packages
cm.add_component("custom", ENV_UNIT_TEST_REPO, "pillow", 0)
cm.add_component("custom", ENV_UNIT_TEST_REPO, "noop-2", 0)
cm.add_component("custom", ENV_UNIT_TEST_REPO, "noop-1", 0)
query = """
{
labbook(owner: "default", name: "labbook55") {
overview {
numAptPackages
numConda2Packages
numConda3Packages
numPipPackages
numCustomDependencies
}
}
}
"""
snapshot.assert_match(
fixture_working_dir_env_repo_scoped[2].execute(query))
def test_create_user_note_no_body(self, fixture_working_dir, snapshot):
"""Test creating and getting a user note"""
# Create labbook
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"}, name="user-note-test", description="testing user notes")
# Create a user note
query = """
mutation makeUserNote {
createUserNote(input: {
owner: "default",
labbookName: "user-note-test",
title: "I think this is a thing"
})
{
newActivityRecordEdge {
node{
message
detailObjects{
data
type
show
importance
tags
}
type
show
importance
tags
}
}
}
}
"""
snapshot.assert_match(fixture_working_dir[2].execute(query))
def test_rename_labbook(self, fixture_working_dir):
"""Test renaming a labbook"""
# Create a dummy labbook to make sure directory structure is set up
lb_dummy = LabBook(fixture_working_dir[0])
lb_dummy.new(owner={"username": "******"}, name="dummy-lb", description="Tester dummy lb")
# Unzip test labbook into working directory
test_zip_file = os.path.join(resource_filename('lmsrvlabbook', 'tests'), 'data', 'test-labbook.zip')
labbooks_dir = os.path.join(fixture_working_dir[1], 'default', 'default', 'labbooks')
with ZipFile(test_zip_file) as zf:
zf.extractall(labbooks_dir)
original_dir = os.path.join(labbooks_dir, 'test-labbook')
new_dir = os.path.join(labbooks_dir, 'test-new-name')
# rename (without the container being previously built)
query = f"""
mutation myMutation{{
renameLabbook(input:{{owner:"default",
originalLabbookName: "test-labbook",
newLabbookName: "test-new-name"}}) {{
success
}}
}}
"""
r = fixture_working_dir[2].execute(query)
assert r['data']['renameLabbook'] is None
assert 'errors' in r
assert 'NotImplemented' in r['errors'][0]['message']
def mock_create_labbooks(fixture_working_dir):
# Create a labbook in the temporary directory
config_file = fixture_working_dir[0]
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": UT_USERNAME},
name=UT_LBNAME,
description="Cats labbook 1")
# Create a file in the dir
with open(os.path.join(fixture_working_dir[1], 'unittest-examplefile'),
'w') as sf:
sf.write("test data")
sf.seek(0)
FileOperations.insert_file(lb, 'code', sf.name)
assert os.path.isfile(
os.path.join(lb.root_dir, 'code', 'unittest-examplefile'))
# Create test client
schema = graphene.Schema(query=LabbookQuery, mutation=LabbookMutations)
with patch.object(Configuration, 'find_default_config',
lambda self: config_file):
app = Flask("lmsrvlabbook")
app.config["LABMGR_CONFIG"] = Configuration()
app.config["LABMGR_ID_MGR"] = get_identity_manager(Configuration())
with app.app_context():
flask.g.user_obj = app.config["LABMGR_ID_MGR"].get_user_profile()
client = Client(
schema,
middleware=[LabBookLoaderMiddleware(), error_middleware],
context_value=ContextMock())
yield lb, client, schema
shutil.rmtree(fixture_working_dir, ignore_errors=True)
def test_file_node(self, fixture_working_dir, snapshot):
"""Test listing labbook favorites"""
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"}, name="labbook1", description="my first labbook1")
# Setup some favorites in code
with open(os.path.join(lb.root_dir, 'code', 'test1.txt'), 'wt') as test_file:
test_file.write("blah1")
# Create favorites
lb.create_favorite("code", "test1.txt", description="My file with stuff 1")
query = """
{
node(id: "TGFiYm9va0ZpbGU6ZGVmYXVsdCZsYWJib29rMSZjb2RlJnRlc3QxLnR4dA==") {
... on LabbookFile {
id
key
isDir
size
}
}
}
"""
snapshot.assert_match(fixture_working_dir[2].execute(query))
def test_package_query(self, snapshot,
fixture_working_dir_env_repo_scoped):
"""Test querying for package info"""
# Create labbook
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
lb.new(owner={"username": "******"},
name="labbook6",
description="my first labbook10000")
query = """
{
labbook(owner: "default", name: "labbook6"){
id
packages(packageInput: [
{manager: "pip", package: "numpy", version:"1.14.2"},
{manager: "pip", package: "scipy", version:""}]){
id
manager
package
version
isValid
}
}
}
"""
snapshot.assert_match(
fixture_working_dir_env_repo_scoped[2].execute(query))
def test_create_user_note_check_vals(self, fixture_working_dir, snapshot):
"""Test to make sure keys and IDs are getting set OK"""
# Create labbook
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"}, name="user-note-test", description="testing user notes")
# Create a user note
query = """
mutation makeUserNote {
createUserNote(input: {
owner: "default",
labbookName: "user-note-test",
title: "I think this is a thing",
body: "##AND THIS IS A BODY\\n- asdggf\\n-asdf",
tags: ["this", "and", "that"]
})
{
newActivityRecordEdge {
node{
message
detailObjects{
id
key
data
type
show
importance
tags
}
id
commit
linkedCommit
type
show
importance
tags
}
cursor
}
}
}
"""
result = fixture_working_dir[2].execute(query)
assert len(result['data']['createUserNote']['newActivityRecordEdge']['node']['id']) > 10
assert type(result['data']['createUserNote']['newActivityRecordEdge']['node']['id']) == str
assert len(result['data']['createUserNote']['newActivityRecordEdge']['node']['commit']) == 40
assert type(result['data']['createUserNote']['newActivityRecordEdge']['node']['commit']) == str
assert result['data']['createUserNote']['newActivityRecordEdge']['node']['linkedCommit'] == "no-linked-commit"
assert result['data']['createUserNote']['newActivityRecordEdge']['node']['message'] == "I think this is a thing"
assert len(result['data']['createUserNote']['newActivityRecordEdge']['node']['detailObjects'][0]['id']) > 10
assert type(result['data']['createUserNote']['newActivityRecordEdge']['node']['detailObjects'][0]['id']) == str
assert len(result['data']['createUserNote']['newActivityRecordEdge']['node']['detailObjects'][0]['key']) > 10
assert type(result['data']['createUserNote']['newActivityRecordEdge']['node']['detailObjects'][0]['key']) == str
assert "AND THIS IS A BODY" in result['data']['createUserNote']['newActivityRecordEdge']['node']['detailObjects'][0]['data'][0][1]
def test_detail_record_node(self, fixture_working_dir, snapshot, fixture_test_file):
"""Test getting an detail record by node ID"""
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"}, name="labbook1", description="my test description")
FileOperations.insert_file(lb, "code", fixture_test_file)
# Get activity record to
query = """
{
labbook(name: "labbook1", owner: "default") {
activityRecords {
edges{
node{
id
commit
linkedCommit
message
type
show
importance
tags
detailObjects{
id
key
type
data
show
importance
tags
}
}
}
}
}
}
"""
result1 = fixture_working_dir[2].execute(query)
query = """
{{
node(id: "{}") {{
... on ActivityDetailObject {{
id
key
type
data
show
importance
tags
}}
}}
}}
""".format(result1['data']['labbook']['activityRecords']['edges'][0]['node']['detailObjects'][0]['id'])
result2 = fixture_working_dir[2].execute(query)
assert result2['data']['node'] == result1['data']['labbook']['activityRecords']['edges'][0]['node']['detailObjects'][0]
def test_get_custom(self, fixture_working_dir_env_repo_scoped, snapshot):
"""Test getting the a LabBook's custom dependencies"""
# Create labbook
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
lb.new(owner={"username": "******"},
name="labbook3",
description="my first labbook10000")
query = """
{
labbook(owner: "default", name: "labbook3") {
environment {
customDependencies {
edges {
node {
id
schema
componentId
repository
revision
name
description
tags
license
url
requiredPackageManagers
dockerSnippet
}
cursor
}
pageInfo {
hasNextPage
hasPreviousPage
}
}
}
}
}
"""
# should be null
snapshot.assert_match(
fixture_working_dir_env_repo_scoped[2].execute(query))
# Add a base image
cm = ComponentManager(lb)
cm.add_component("custom", ENV_UNIT_TEST_REPO, "pillow", 0)
# Test again
r2 = fixture_working_dir_env_repo_scoped[2].execute(query)
assert 'errors' not in r2
snapshot.assert_match(r2)
def mock_create_labbooks(fixture_working_dir):
# Create a labbook in the temporary directory
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"}, name="labbook1", description="Cats labbook 1")
# Create a file in the dir
with open(os.path.join(fixture_working_dir[1], 'sillyfile'), 'w') as sf:
sf.write("1234567")
sf.seek(0)
FileOperations.insert_file(lb, 'code', sf.name)
assert os.path.isfile(os.path.join(lb.root_dir, 'code', 'sillyfile'))
# name of the config file, temporary working directory, the schema
yield fixture_working_dir
def test_add_package(self, fixture_working_dir_env_repo_scoped, snapshot):
"""Test listing labbooks"""
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
labbook_dir = lb.new(name="catbook-package-tester",
description="LB to test package mutation",
owner={"username": "******"})
# Add a base image
pkg_query = """
mutation myPkgMutation {
addPackageComponents (input: {
owner: "default",
labbookName: "catbook-package-tester",
packages: [{manager: "conda3", package: "requests", version: "2.18.4"}]
}) {
clientMutationId
newPackageComponentEdges {
node{
id
schema
manager
package
version
fromBase
}
cursor
}
}
}
"""
snapshot.assert_match(
fixture_working_dir_env_repo_scoped[2].execute(pkg_query))
def test_remove_custom_dep(self, fixture_working_dir_env_repo_scoped,
snapshot):
"""Test removing a custom dependency"""
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
labbook_dir = lb.new(name="labbook-remove-custom",
description="my first labbook",
owner={"username": "******"})
# Add a custom dep
query = """
mutation myEnvMutation{
addCustomComponent(input: {
owner: "default",
labbookName: "labbook-remove-custom",
repository: "gig-dev_components2",
componentId: "pillow",
revision: 0
}) {
clientMutationId
newCustomComponentEdge {
node{
repository
componentId
revision
name
description
}
}
}
}
"""
snapshot.assert_match(
fixture_working_dir_env_repo_scoped[2].execute(query))
# Verify file
component_file = os.path.join(labbook_dir, '.gigantum', 'env',
'custom',
"gig-dev_components2_pillow.yaml")
assert os.path.exists(component_file) is True
# Remove a custom dep
query = """
mutation myEnvMutation{
removeCustomComponent(input: {
owner: "default",
labbookName: "labbook-remove-custom",
repository: "gig-dev_components2",
componentId: "pillow"
}) {
clientMutationId
success
}
}
"""
snapshot.assert_match(
fixture_working_dir_env_repo_scoped[2].execute(query))
assert os.path.exists(component_file) is False
def test_load_one(self, fixture_working_dir):
"""Test loading 1 labbook"""
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"},
name="labbook1",
description="my first labbook1")
lb.new(owner={"username": "******"},
name="labbook2",
description="my first labbook2")
loader = LabBookLoader()
key = f"default&default&labbook1"
promise1 = loader.load(key)
assert isinstance(promise1, Promise)
lb = promise1.get()
assert lb.name == "labbook1"
assert lb.description == "my first labbook1"
def test_favorites_node(self, fixture_working_dir, snapshot):
"""Test listing labbook favorites"""
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"}, name="labbook1", description="my first labbook1")
# Setup some favorites in code
with open(os.path.join(lb.root_dir, 'code', 'test1.txt'), 'wt') as test_file:
test_file.write("blah1")
# Create favorites
lb.create_favorite("code", "test1.txt", description="My file with stuff 1")
# Test bad node that isn't a file
query = """
{
node(id: "TGFiYm9va0Zhdm9yaXRlOmRlZmF1bHQmbGFiYm9vazEmY29kZSZ0ZXN0MzMzLnR4dA==") {
... on LabbookFavorite {
id
key
description
isDir
index
}
}
}
"""
snapshot.assert_match(fixture_working_dir[2].execute(query))
# Get the actual item
query = """
{
node(id: "TGFiYm9va0Zhdm9yaXRlOmRlZmF1bHQmbGFiYm9vazEmY29kZSZ0ZXN0MS50eHQ=") {
... on LabbookFavorite {
id
key
description
isDir
index
}
}
}
"""
snapshot.assert_match(fixture_working_dir[2].execute(query))
def test_get_environment_status(self, fixture_working_dir, snapshot):
"""Test getting the a LabBook's environment status"""
# Create labbooks
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"},
name="labbook10",
description="my first labbook10000")
query = """
{
labbook(owner: "default", name: "labbook10") {
environment {
containerStatus
imageStatus
}
}
}
"""
snapshot.assert_match(fixture_working_dir[2].execute(query))
def test_no_remote_url(self, fixture_working_dir_env_repo_scoped,
snapshot):
"""Test getting the a LabBook's remote url without publish"""
# Create labbook
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
lb.new(owner={"username": "******"},
name="labbook6",
description="my first labbook10000")
query = """
{
labbook(owner: "default", name: "labbook6") {
overview {
remoteUrl
}
}
}
"""
snapshot.assert_match(
fixture_working_dir_env_repo_scoped[2].execute(query))
def test_node_labbook_from_object(self, fixture_working_dir, snapshot):
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"}, name="cat-lab-book1", description="Test cat labbook from obj")
query = """
{
node(id: "TGFiYm9vazpkZWZhdWx0JmNhdC1sYWItYm9vazE=") {
... on Labbook {
name
description
activeBranch {
refName
}
}
id
}
}
"""
snapshot.assert_match(fixture_working_dir[2].execute(query))
def test_node_package(self, fixture_working_dir, snapshot):
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"}, name="node-env-test-lb", description="Example labbook by mutation.")
env_query = """
{
node(id: "UGFja2FnZUNvbXBvbmVudDpwaXAmbnVtcHkmMS4xMg==") {
id
... on PackageComponent {
manager
package
version
latestVersion
}
}
}
"""
results = fixture_working_dir[2].execute(env_query)
results['data']['node']['manager'] == 'pip'
results['data']['node']['package'] == 'numpy'
results['data']['node']['version'] == '1.12'
def test_load_many(self, fixture_working_dir):
"""Test loading many labbooks"""
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"},
name="labbook1",
description="my first labbook1")
lb.new(owner={"username": "******"},
name="labbook2",
description="my first labbook2")
lb.new(username="******",
owner={"username": "******"},
name="labbook2",
description="my first labbook3")
loader = LabBookLoader()
keys = [
"default&default&labbook1", "default&default&labbook2",
"default&test3&labbook2"
]
promise1 = loader.load_many(keys)
assert isinstance(promise1, Promise)
lb_list = promise1.get()
assert lb_list[0].name == "labbook1"
assert lb_list[0].description == "my first labbook1"
assert lb_list[1].name == "labbook2"
assert lb_list[1].description == "my first labbook2"
assert lb_list[2].name == "labbook2"
assert lb_list[2].description == "my first labbook3"
def test_custom_docker_snippet_success(
self, fixture_working_dir_env_repo_scoped):
"""Test adding a custom dependency"""
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
labbook_dir = lb.new(name="custom-docker-lb-unittest",
description="Testing custom docker and stuff",
owner={"username": "******"})
client = fixture_working_dir_env_repo_scoped[2]
query = """
mutation addCustomDocker($labbook_name: String!, $owner: String!, $custom_docker: String!) {
addCustomDocker(input: {
owner: $owner,
labbookName: $labbook_name,
dockerContent: $custom_docker
}) {
updatedEnvironment {
dockerSnippet
}
}
}
"""
vars = {
'labbook_name': "custom-docker-lb-unittest",
'owner': 'default',
'custom_docker': "RUN true"
}
r = client.execute(query, variable_values=vars)
assert 'errors' not in r
assert r['data']['addCustomDocker']['updatedEnvironment'][
'dockerSnippet'] == "RUN true"
remove_query = """
mutation removeCustomDocker($labbook_name: String!, $owner: String!) {
removeCustomDocker(input: {
owner: $owner,
labbookName: $labbook_name
}) {
updatedEnvironment {
dockerSnippet
}
}
}
"""
vars = {
'labbook_name': "custom-docker-lb-unittest",
'owner': 'default'
}
r = client.execute(remove_query, variable_values=vars)
assert 'errors' not in r
assert r['data']['removeCustomDocker']['updatedEnvironment'][
'dockerSnippet'] == ""
def test_add_packages_multiple_mgr_error(
self, fixture_working_dir_env_repo_scoped, snapshot):
"""Test listing labbooks"""
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
lb.new(name="catbook-package-tester-mgr-errors",
description="LB to test package mutation",
owner={"username": "******"})
# Test with version missing
pkg_query = """
mutation myPkgMutation {
addPackageComponents (input: {
owner: "default",
labbookName: "catbook-package-tester-mgr-errors",
packages: [{manager: "pip3", package: "requests", version: "2.18.4"},
{manager: "conda3", package: "responses", version: "1.4"}]
}) {
clientMutationId
newPackageComponentEdges {
node{
id
schema
manager
package
version
fromBase
}
cursor
}
}
}
"""
result = fixture_working_dir_env_repo_scoped[2].execute(pkg_query)
assert "errors" in result
assert result['errors'][0][
'message'] == 'Only batch add packages via 1 package manager at a time.'
def test_node_environment(self, fixture_working_dir, snapshot):
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"}, name="node-env-test-lb", description="Example labbook by mutation.")
env_query = """
{
node(id: "TGFiYm9vazpkZWZhdWx0Jm5vZGUtZW52LXRlc3QtbGI=") {
id
... on Labbook {
name
description
environment {
id
imageStatus
containerStatus
}
}
}
}
"""
results = fixture_working_dir[2].execute(env_query)
snapshot.assert_match(results)
env_id = results['data']['node']['environment']['id']
env_node_query = """
{
node(id: "%s") {
id
... on Environment {
imageStatus
containerStatus
}
}
}
""" % env_id
snapshot.assert_match(fixture_working_dir[2].execute(env_node_query))
def test_empty_package_counts(self, fixture_working_dir_env_repo_scoped,
snapshot):
"""Test getting the a LabBook's package manager dependencies"""
# Create labbook
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
lb.new(owner={"username": "******"},
name="labbook4",
description="my first labbook10000")
query = """
{
labbook(owner: "default", name: "labbook4") {
overview {
numAptPackages
numConda2Packages
numConda3Packages
numPipPackages
numCustomDependencies
}
}
}
"""
snapshot.assert_match(
fixture_working_dir_env_repo_scoped[2].execute(query))
def test_add_package_no_version(self, fixture_working_dir_env_repo_scoped,
snapshot):
"""Test adding a package but omitting the version"""
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
labbook_dir = lb.new(name="catbook-package-no-version",
description="LB to test package mutation",
owner={"username": "******"})
# Add a base image
pkg_query = """
mutation myPkgMutation {
addPackageComponents (input: {
owner: "default",
labbookName: "catbook-package-no-version",
packages: [{manager: "pip3", package: "requests"}]
}) {
clientMutationId
newPackageComponentEdges {
node{
id
schema
manager
package
version
fromBase
}
cursor
}
}
}
"""
result = fixture_working_dir_env_repo_scoped[2].execute(pkg_query)
assert "errors" in result
assert result['errors'][0]['message'] == "'version'"
def test_build_image(self, fixture_working_dir_env_repo_scoped,
reset_images):
"""Test building a labbook's image"""
# Create labbook
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
lb.new(owner={"username": "******"},
name="labbook-build1",
description="building an env")
# add a base
cm = ComponentManager(lb)
cm.add_component("base", "gig-dev_components2", "ut-busybox", 0)
query = """
{
labbook(name: "labbook-build1", owner: "default") {
environment {
imageStatus
containerStatus
}
}
}
"""
r = fixture_working_dir_env_repo_scoped[2].execute(query)
assert 'errors' not in r
assert r['data']['labbook']['environment'][
'imageStatus'] == 'DOES_NOT_EXIST'
assert r['data']['labbook']['environment'][
'containerStatus'] == 'NOT_RUNNING'
# Build the image
build_query = """
mutation myBuildImage {
buildImage(input: {labbookName: "labbook-build1", owner: "default"}) {
environment {
imageStatus
containerStatus
}
}
}
"""
r = fixture_working_dir_env_repo_scoped[2].execute(build_query)
import pprint
pprint.pprint(r)
assert 'errors' not in r
assert r['data']['buildImage']['environment']['imageStatus'] in [
'BUILD_QUEUED', 'BUILD_IN_PROGRESS'
]
assert r['data']['buildImage']['environment'][
'containerStatus'] == 'NOT_RUNNING'
## Sneak in a test for background jobs
get_bg_jobs_query = """
{
labbook(name: "labbook-build1", owner: "default") {
backgroundJobs {
jobKey
status
failureMessage
jobMetadata
startedAt
result
}
}
}
"""
r = fixture_working_dir_env_repo_scoped[2].execute(get_bg_jobs_query)
assert 'errors' not in r, "There should be no errors when querying for background job status"
assert r['data']['labbook']['backgroundJobs'][0][
'status'], "Background Jobs status query should not be None"
pprint.pprint(r)
# Wait for build to succeed for up to TIMEOUT_MAX seconds
success = False
for _ in range(TIMEOUT_MAX):
result = fixture_working_dir_env_repo_scoped[2].execute(query)
if result['data']['labbook']['environment'][
'imageStatus'] == 'EXISTS':
success = True
break
assert result['data']['labbook']['environment'][
'imageStatus'] == 'BUILD_IN_PROGRESS'
time.sleep(1)
r = fixture_working_dir_env_repo_scoped[2].execute(get_bg_jobs_query)
assert 'errors' not in r
assert r['data']['labbook']['backgroundJobs'][0][
'status'] == 'finished'
assert r['data']['labbook']['backgroundJobs'][0]['result'].isalnum()
assert 'build_image' in r['data']['labbook']['backgroundJobs'][0][
'jobMetadata']
pprint.pprint(r)
assert success is True, f"Failed to build within {TIMEOUT_MAX} second timeout."
r = fixture_working_dir_env_repo_scoped[2].execute(query)
assert 'errors' not in r
assert r['data']['labbook']['environment']['imageStatus'] == 'EXISTS'
assert r['data']['labbook']['environment'][
'containerStatus'] == 'NOT_RUNNING'
def test_get_package_manager(self, fixture_working_dir_env_repo_scoped,
snapshot):
"""Test getting the a LabBook's package manager dependencies"""
# Create labbook
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
lb.new(owner={"username": "******"},
name="labbook4",
description="my first labbook10000")
query = """
{
labbook(owner: "default", name: "labbook4") {
environment {
packageDependencies {
edges {
node {
id
schema
manager
package
version
fromBase
}
cursor
}
pageInfo {
hasNextPage
}
}
}
}
}
"""
# should be null
snapshot.assert_match(
fixture_working_dir_env_repo_scoped[2].execute(query))
# Add a base image
cm = ComponentManager(lb)
pkgs = [{
"manager": "pip",
"package": "requests",
"version": "1.3"
}, {
"manager": "pip",
"package": "numpy",
"version": "1.12"
}]
cm.add_packages('pip', pkgs)
# Add one package without a version, which should cause an error in the API since version is required
pkgs = [{
"manager": "apt",
"package": "docker",
"version": ""
}, {
"manager": "apt",
"package": "lxml",
"version": "3.4"
}]
cm.add_packages('apt', pkgs)
# Test again
snapshot.assert_match(
fixture_working_dir_env_repo_scoped[2].execute(query))
query = """
{
labbook(owner: "default", name: "labbook4") {
environment {
packageDependencies(first: 2, after: "MA==") {
edges {
node {
id
manager
package
version
fromBase
}
cursor
}
pageInfo {
hasNextPage
}
}
}
}
}
"""
r1 = fixture_working_dir_env_repo_scoped[2].execute(query)
assert 'errors' not in r1
snapshot.assert_match(r1)
def test_build_image_no_cache(self, fixture_working_dir_env_repo_scoped,
reset_images):
"""Test building a labbook's image"""
# Create labbook
lb = LabBook(fixture_working_dir_env_repo_scoped[0])
lb.new(owner={"username": "******"},
name="labbook-build2",
description="building an env")
# add a base
cm = ComponentManager(lb)
cm.add_component("base", "gig-dev_components2", "ut-busybox", 0)
query = """
{
labbook(name: "labbook-build2", owner: "default") {
environment {
imageStatus
containerStatus
}
}
}
"""
r = fixture_working_dir_env_repo_scoped[2].execute(query)
assert 'errors' not in r
assert r['data']['labbook']['environment'][
'imageStatus'] == 'DOES_NOT_EXIST'
assert r['data']['labbook']['environment'][
'containerStatus'] == 'NOT_RUNNING'
# Build the image
build_query = """
mutation myBuildImage {
buildImage(input: {labbookName: "labbook-build2", owner: "default", noCache: true}) {
environment {
imageStatus
containerStatus
}
}
}
"""
r = fixture_working_dir_env_repo_scoped[2].execute(build_query)
assert 'errors' not in r
assert r['data']['buildImage']['environment']['imageStatus'] in [
'BUILD_QUEUED', 'BUILD_IN_PROGRESS'
]
assert r['data']['buildImage']['environment'][
'containerStatus'] == 'NOT_RUNNING'
# Wait for build to succeed for up to TIMEOUT_MAX seconds
success = False
for _ in range(TIMEOUT_MAX):
result = fixture_working_dir_env_repo_scoped[2].execute(query)
if result['data']['labbook']['environment'][
'imageStatus'] == 'EXISTS':
success = True
break
assert result['data']['labbook']['environment'][
'imageStatus'] == 'BUILD_IN_PROGRESS'
time.sleep(1)
assert success is True, f"Failed to build within {TIMEOUT_MAX} second timeout."
r = fixture_working_dir_env_repo_scoped[2].execute(query)
assert 'errors' not in r
assert r['data']['labbook']['environment']['imageStatus'] == 'EXISTS'
assert r['data']['labbook']['environment'][
'containerStatus'] == 'NOT_RUNNING'
def mutate_and_get_payload(cls,
root,
info,
name,
description,
repository,
component_id,
revision,
is_untracked=False,
client_mutation_id=None):
username = get_logged_in_username()
# Create a new empty LabBook
lb = LabBook(author=get_logged_in_author())
# TODO: Set owner/namespace properly once supported fully
lb.new(owner={"username": username},
username=username,
name=name,
description=description,
bypass_lfs=is_untracked)
if is_untracked:
FileOperations.set_untracked(lb, 'input')
FileOperations.set_untracked(lb, 'output')
input_set = FileOperations.is_set_untracked(lb, 'input')
output_set = FileOperations.is_set_untracked(lb, 'output')
if not (input_set and output_set):
raise ValueError(
f'{str(lb)} untracking for input/output in malformed state'
)
if not lb.is_repo_clean:
raise ValueError(
f'{str(lb)} should have clean Git state after setting for untracked'
)
# Create a Activity Store instance
store = ActivityStore(lb)
# Create detail record
adr = ActivityDetailRecord(ActivityDetailType.LABBOOK,
show=False,
importance=0)
adr.add_value('text/plain', f"Created new LabBook: {username}/{name}")
# Create activity record
ar = ActivityRecord(ActivityType.LABBOOK,
message=f"Created new LabBook: {username}/{name}",
show=True,
importance=255,
linked_commit=lb.git.commit_hash)
ar.add_detail_object(adr)
# Store
store.create_activity_record(ar)
# Add Base component
cm = ComponentManager(lb)
cm.add_component("base", repository, component_id, revision)
# Prime dataloader with labbook you just created
dataloader = LabBookLoader()
dataloader.prime(f"{username}&{username}&{lb.name}", lb)
# Get a graphene instance of the newly created LabBook
return CreateLabbook(labbook=Labbook(owner=username, name=lb.name))
def mock_create_labbooks(fixture_working_dir):
# Create a labbook in the temporary directory
lb = LabBook(fixture_working_dir[0])
lb.new(owner={"username": "******"}, name="labbook1", description="Test labbook 1")
yield fixture_working_dir
def test_list_remote_labbooks_az(self, fixture_working_dir, snapshot):
"""test list labbooks"""
lb = LabBook(fixture_working_dir[0])
lb.new(username='******',
owner={"username": "******"},
name="test11",
description="my first labbook1")
responses.add(responses.GET,
'https://usersrv.gigantum.io/key',
json={'key': 'afaketoken'},
status=200)
dummy_data = [{
"id": 118,
"name": "test11",
"name_with_namespace": "testuser / test11",
"path_with_namespace": "testuser/test11",
"created_at": "2018-04-19T19:06:11.009Z",
"last_activity_at": "2018-04-19T22:08:05.974Z",
"visibility": "private",
"owner": {
"id": 14,
"name": "testuser",
"username": "******",
"state": "active",
},
"creator_id": 14,
"namespace": {
"id": 14,
"name": "testuser",
"path": "testuser",
"kind": "user",
"full_path": "testuser"
},
"import_status": "none",
"permissions": {
"project_access": {
"access_level": 30,
"notification_level": 3
},
}
}, {
"id": 138,
"name": "test2",
"name_with_namespace": "testuser / test2",
"path_with_namespace": "testuser/test2",
"created_at": "2018-04-19T19:36:11.009Z",
"last_activity_at": "2018-04-19T20:58:05.974Z",
"visibility": "private",
"owner": {
"id": 14,
"name": "testuser",
"username": "******",
"state": "active",
},
"creator_id": 14,
"namespace": {
"id": 14,
"name": "testuser",
"path": "testuser",
"kind": "user",
"full_path": "testuser"
},
"import_status": "none",
"permissions": {
"project_access": {
"access_level": 30,
"notification_level": 3
},
}
}]
responses.add(responses.GET,
'https://repo.gigantum.io/api/v4/projects/',
json=dummy_data,
status=200)
list_query = """
{
labbookList{
remoteLabbooks(sort: "az", reverse: false){
edges{
node{
id
description
creationDateUtc
modifiedDateUtc
name
owner
isLocal
}
cursor
}
pageInfo{
hasNextPage
}
}
}
}"""
r = fixture_working_dir[2].execute(list_query)
print(r)
assert 'errors' not in r
snapshot.assert_match(r)
list_query = """
{
labbookList{
remoteLabbooks(sort: "modified_on", reverse: false){
edges{
node{
id
description
creationDateUtc
modifiedDateUtc
name
owner
}
cursor
}
pageInfo{
hasNextPage
}
}
}
}"""
r = fixture_working_dir[2].execute(list_query)
assert 'errors' not in r
snapshot.assert_match(r)
