Slangroom examples

db plugin examples

read a record from a table

read_from_table.slang

Rule unknown ignore

Given I connect to 'database' and send record 'id' and send table 'table' and read the record of the table and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

read_from_table.data.json

{
	"id": 1,
	"table": "table"
}

read_from_table.keys.json

{
	"database": "sqlite://user:password@url/to/your/db"
}

save a variable in a database table

save_to_table.slang

Rule unknown ignore

Given I have a 'string' named 'database'
Given I have a 'string' named 'table'
When I set 'variable' to 'value to be stored' as 'string'
When I set 'name' to 'key under which save the variable' as 'string'
Then print the 'database'
Then print the 'variable'
Then print the 'name'
Then print the 'table'

Then I connect to 'database' and send variable 'variable' and send name 'name' and send table 'table' and save the variable in the database table

save_to_table.data.json

{
    "table": "table"
}

save_to_table.keys.json

{
	"database": "sqlite://user:password@url/to/your/db"
}

execute generic sql statements

sql_statement.slang

Rule unknown ignore

Given I connect to 'database' and send statement 'statement' and execute sql statement and output into 'result'

Given I have a 'string array' named 'result'
Then print all data

sql_statement.data.json

{
    "statement": "SELECT * FROM table"
}

sql_statement.keys.json

{
	"database": "sqlite://user:password@url/to/your/db"
}

execute generic sql statements with parameters

sql_statement_with_params.slang

Rule unknown ignore

Given I connect to 'database' and send statement 'statement' and send parameters 'parameters'  and execute sql statement with parameters and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

sql_statement_with_params.data.json

{
	"statement": "INSERT INTO table (name) VALUES (?)",
	"params": ["John Doe"]
}

sql_statement_with_params.keys.json

{
	"database": "sqlite://user:password@url/to/your/db"
}

ethereum plugin examples

complex example

complex.slang

Rule unknown ignore
Scenario 'ethereum': Store an object on eth

Given I connect to 'ethereum' and send address 'address' and read the ethereum nonce and output into 'ethereum_nonce'
Given I connect to 'ethereum' and read the suggested gas price and output into 'gas_price'

# from slangroom
Given I have a 'ethereum nonce'
Given I have a 'gas price'

# from keys
Given I have the 'keyring'

# from data
Given I have a 'ethereum address' named 'storage contract'
Given I have a 'string' named 'to be stored'
Given I have a 'gas limit'

# create the signed transaction to store the data
When I create the ethereum transaction to 'storage contract'
When I use the ethereum transaction to store 'to be stored'
When I create the signed ethereum transaction for chain 'fabt'

Then print the 'signed ethereum transaction'

Then I connect to 'ethereum' and send transaction 'signed_ethereum_transaction' and read the ethereum transaction id after broadcast and output into 'transaction_id'

complex.data.json

{
    "gas_limit": "100000",
	"storage_contract": "0x662c4017C01bA23c94257289Dab8C2757b472B81",
	"to_be_srtored": "Some data",
}

complex.keys.json

{
	"ethereum": "http://78.47.38.223:9485",
	"keyring": {
		"ethereum": "078ad84d6c7a50c6dcd983d644da65e30d8cea063d8ea49aeb7ee7f0aaf6a4f7"
	}
}

read the ethereum balance

read_balance.slang

Rule unknown ignore

Given I connect to 'ethereum' and send address 'address' and read the ethereum balance and output into 'balance'
Given I connect to 'ethereum' and send addresses 'addresses' and read the ethereum balance and output into 'balances'

Given I have a 'string' named 'balance'
Given I have a 'string array' named 'balances'
Then print the data

read_balance.data.json

{
	"address": "0x2D010920b43aFb54f8d5fB51c9354FbC674b28Fc",
	"addresses": [
		"0xc32510251F77382bb9214144D2c488408Ec2047C",
		"0xFf02577F140557190693cFf549025e66119FEA52",
		"0x4743879F5e9dc3fcE41E30380365441E8D14CCEc"
    ]
}

read_balance.keys.json

{
	"ethereum": "http://78.47.38.223:9485"
}

read the ethereum transaction body

read_bytes.slang

Rule unknown ignore
Scenario 'ethereum': read transaction

Given I connect to 'ethereum' and send transaction_id 'tag' and read the ethereum bytes and output into 'hex_result'

Given I have a 'hex' named 'hex_result'
When I create the string from the ethereum bytes named 'hex_result'
When I rename the 'string' to 'string_result'
Then print data

read_bytes.data.json

{
	"tag": "0467636a2557a1ccdaf10ce17ee74340096c510acfa9181c85756d43a8bed522"
}

read_bytes.keys.json

{
	"ethereum": "http://78.47.38.223:9485"
}

read the ethereum suggested gas price

read_gas.slang

Rule unknown ignore
Scenario 'ethereum': read gas price

Given I connect to 'ethereum' and read the ethereum suggested gas price and output into 'gas_price'

Given I have a 'gas price'
Then print the data

read_gas.data.json

{}

read_gas.keys.json

{
	"ethereum": "http://78.47.38.223:9485"
}

read the ethereum nonce

read_nonce.slang

Rule unknown ignore
Scenario 'ethereum': read nonce

Given I connect to 'ethereum' and send address 'address' and read the ethereum nonce and output into 'ethereum_nonce'

Given I have a 'ethereum nonce'
Then print the 'ethereum_nonce'

read_nonce.data.json

{
	"address": "0x7d6df85bDBCe99151c813fd1DDE6BC007c523C27"
}

read_nonce.keys.json

{
	"ethereum": "http://78.47.38.223:9485"
}

read the ethereum transaction id after broadcast

read_tx_id.slang

Rule unknown ignore

Given I connect to 'ethereum' and send transaction 'signed_transaction' and read the ethereum transaction id after broadcast and output into 'transaction_id'

Given I have a 'string' named 'transaction_id'
Then print the data

read_tx_id.data.json

{
    "signed_transaction": "f8ee8085174876e800830493e094e54c7b475644fbd918cfedc57b1c9179939921e680b884b374012b0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003354686973206973206d7920666972737420646174612073746f726564206f6e20657468657265756d20626c6f636b636861696e0000000000000000000000000084ccc2c50ca0776b58c34145c9553b5235fe211a6237c48b90b4784bc6d86660b0236af3bab2a07b57259d71f12666d962eb7a06b2b8332323a614071d0b39c35181b2aee04b8e"
}

read_tx_id.keys.json

{
	"ethereum": "http://78.47.38.223:9485"
}

fs plugin examples

verify file exists or does not exist

exist.slang

Rule unknown ignore
Given I send path 'file_path_1' and verify file exists
Given I send path 'file_path_2' and verify file does not exist
Given I have a 'string' named 'file_path_1'
Then print the 'file_path_1'

exist.data.json

{
	"file_path_1": "path/to/file/that/should/exists/from/FILES_DIR",
	"file_path_2": "path/to/file/that/should/not/exists/from/FILES_DIR"
}

exist.keys.json

{}

list a directory content

ls.slang

Rule unknown ignore
Given I send path 'directory_path' and list directory content and output into 'directory_content'
Given I have a 'string array' named 'directory_content'
Then print the 'directory_content'

ls.data.json

{
	"directory_path": "path/to/directory/from/FILES_DIR"
}

ls.keys.json

{}

read json file

read_json.slang

Rule unknown ignore
Given I send path 'file_path' and read file content and output into 'file_content'
Given I have a 'string dictionay' named 'file_content'
Then print the 'file_content'

read_json.data.json

{
	"file_path": "path/to/file/from/FILES_DIR"
}

read_json.keys.json

{}

read string file

read_verbatim.slang

Rule unknown ignore
Given I send path 'file_path' and read verbatim file content and output into 'file_content'
Given I have a 'string' named 'file_content'
Then print the 'file_content'

read_verbatim.data.json

{
	"file_path": "path/to/file/from/FILES_DIR"
}

read_verbatim.keys.json

{}

store in file

store.slang

Rule unknown ignore
Given I have a 'string' named 'file_path'
When I create the random object of '128' bits
Then print the 'random_object'
Then print the 'file_path'
Then I send path 'file_path' and send content 'random_object' and store in file

store.data.json

{
	"file_path": "path/to/file/from/FILES_DIR"
}

store.keys.json

{}

git plugin examples

clone repository

clone_repository.slang

Rule unknown ignore

Given I connect to 'url' and send path 'path' and clone repository

Given I have a 'string' named 'cloned_repository'
Then print the data

clone_repository.data.json

{
	"cloned_repository": "true"
}

clone_repository.keys.json

{
	"url": "https://github.com/dyne/slangroom",
	"path": "slangroom"
}

create new git commit

commit.slang

Rule unknown ignore

Given I open 'path' and send commit 'commit' and create new git commit and output into 'commit_hash'

Given I have a 'string' named 'commit hash'
Then print the data

commit.data.json

{
	"commit": {
		"author": "Jhon Doe",
		"message": "docs: update readme",
		"email": "jhon.doe@example.com",
		"files": [ "README.md" ]
	},
}

commit.keys.json

{
	"path": "slangroom"
}

verify git repository

verify_git.slang

Rule unknown ignore

Given I open 'path' and verify git repository

Given I have a 'string' named 'verified_git_repo'
Then print data

verify_git.data.json

{
	"verified_git_repo": "true"
}

verify_git.keys.json

{
    "path": "path/to/repository"
}

helpers plugin examples

manipulate and compact

compact.slang

Rule unknown ignore

Given I send array 'array' and manipulate and compact and output into 'result'

Given I have a 'string array' named 'result'
Then print the data

compact.data.json

{
	"the_array": [
		0,
		"c",
		false,
		"d",
		""
	]
}

compact.keys.json

{}

manipulate and concat

concat.slang

Rule unknown ignore

Given I send array 'array' and send values 'values' and manipulate and concat and output into 'result'

Given I have a 'string array' named 'result'
Then print the data

concat.data.json

{
    "array": [
		"first",
		"second"
	]
}

concat.keys.json

{
	"values": [
		"third",
		"foruth",
		"fifth"
	]
}

manipulate and get

get.slang

Rule unknown ignore

Given I send object 'object' and send path 'path' and manipulate and get and output into 'result'

Given I have a 'string' named 'result'
Then print the data

get.data.json

{
	"object": {
		"root": {
			"element": "value"
		}
	}
}

get.keys.json

{
	"the_path": "root.element"
}

manipulate and merge

merge.slang

Rule unknown ignore

Given I send object 'object' and send sources 'sources' and manipulate and merge and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the data

merge.data.json

{
	"object": {
		"names": {
			"first": "Bella",
			"third": "Owen"
		},
		"surnames": {
			"first": "Allen",
			"second": "Briggs"
		}
	}
}

merge.keys.json

{
	"sources": [
		{
			"names": {
				"second": "Jhon"
			}
		},
		{
			"surnames": {
				"third": "Doe"
			}
		}
	]
}

manipulate and omit

omit.slang

Rule unknown ignore

Given I send object 'object' and send paths 'paths' and manipulate and omit and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the data

omit.data.json

{
	"object": {
		"names": {
			"first": "Bella",
			"third": "Owen"
		},
		"surnames": {
			"first": "Allen",
			"second": "Briggs"
		}
	}
}

omit.keys.json

{
	"path": [
		"names.third",
		"surnames.second"
	]
}

manipulate and pick

pick.slang

Rule unknown ignore

Given I send object 'object' and send properties 'properties' and manipulate and pick and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the data

pick.data.json

{
	"object": {
		"name": "Jhon",
		"personal_information": {
			"email": {
				"frist": "example@example.org",
				"second": "email@example.org"
			},
			"phone": "3338957823"
		}
	}
}

pick.keys.json

{
	"properties": [
		"name",
		"personal_information.email.first"
	]
}

manipulate and set

set.slang

Rule unknown ignore

Given I send object 'object' and send path 'path' and send value 'value' and manipulate and set

Given I have a 'string dictionary' named 'object'
Then print 'mimmo'

set.data.json

{
	"value": { "name": "Jhon" },
	"object": {
		"surname": "Doe"
	}
}

set.keys.json

{
	"path": "root.element"
}

http plugin examples

http get

get.slang

Rule unknown ignore
Given I connect to 'address' and do get and output into 'result'
Given I have a 'string dictionary' named 'result'
Then print the 'result'

get.data.json

{
	"address": "https://dyne.org/slangroom"
}

get.keys.json

{
	"secret": "foo"
}

http get with headers

get_with_headers.slang

Rule unknown ignore
Given I connect to 'address' and send headers 'headers' and do get and output into 'result'
Given I have a 'string dictionary' named 'result'
Then print the 'result'

get_with_headers.data.json

{
	"headers": {
		"Content-Type": "application/json"
	}
}

get_with_headers.keys.json

{
	"address": "https://dyne.org/slangroom"
}

http post

post.slang

Rule unknown ignore
Given I connect to 'address' and send object 'body' and do post and output into 'result'
Given I have a 'string dictionary' named 'result'
Then print the 'result'

post.data.json

{
	"body": {
		"hello": "world"
	}
}

post.keys.json

{
	"address": "https://dyne.org/slangroom"
}

http post with header

post_with_headers.slang

Rule unknown ignore
Given I connect to 'address' and send object 'body' and send headers 'headers' and do post and output into 'result'
Given I have a 'string dictionary' named 'result'
Then print the 'result'

post_with_headers.data.json

{
	"body": {
		"hello": "world"
	},
	"headers": {
		"Content-Type": "application/json"
	}
}

post_with_headers.keys.json

{
	"address": "https://dyne.org/slangroom"
}

json-schema plugin examples

validate json

validate.slang

Rule unknown ignore

Given I send json_data 'json_data' and send json_schema 'json_schema' and validate json and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

validate.data.json

{
    "json_data": {
        "first_name": "Jhon",
        "last_name": "Doe"
    }
}

validate.keys.json

{
	"json_schema": {
		"type": "object",
		"properties": {
			"first_name": {
				"type": "string"
			},
			"last_name": {
				"type": "string"
			}
		},
		"required": [
			"first_name",
			"last_name"
		]
	}
}

oauth plugin examples

add data to authorization details

add_data.slang

Rule unknown ignore

Given I send request_uri 'request_uri' and send data 'data' and send server_data 'server' and add data to authorization details and output into 'result'

Given I have a 'string array' named 'result'
Then print the 'result'

add_data.data.json

{
	"request_uri": "urn:ietf:params:oauth:request_uri:1719239545ed9f269e652d207b90dec394b87225c92346023b",
	"data": {
		"email": "email@example.com"
	}
}

add_data.keys.json

{
	"server_data": {
		"jwk": {
			"kty": "EC",
			"crv": "P-256",
			"alg": "ES256",
			"x": "SVqB4JcUD6lsfvqMr-OKUNUphdNn64Eay60978ZlL74",
			"y": "lf0u0pMj4lGAzZix5u4Cm5CMQIgMNpkwy163wtKYVKI",
			"d": "0g5vAEKzugrXaRbgKG0Tj2qJ5lMP4Bezds1_sTybkfk"
		},
		"url": "https://valid.issuer.url",
		"authentication_url": "https://did.dyne.org/dids/"
	}
}

generate access token

gen_access_token.slang

Rule unknown ignore
Scenario 'http': url encode

Given I have a 'string dictionary' named 'json_body'
Given I have a 'string dictionary' named 'request'

When I create the http get parameters from 'json_body' using percent encoding
When I move 'json_body' to 'body' in 'request'

Then print the 'request'

Then I send request 'request' and send server_data 'server_data' and generate access token and output into 'result'

gen_access_token.data.json

{
	"json_body": {
		"grant_type": "authorization_code",
		"client_id": "did:dyne:sandbox.genericissuer:6Cp8mPUvJmQaMxQPSnNyhb74f9Ga4WqfXCkBneFgikm5",
		"code_verifier": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk",
		"redirect_uri": "https://Wallet.example.org/cb",
		"code": "eyJhbGciOiJFUzI1NiIsImp3ayI6eyJrdHkiOiJFQyIsIngiOiJ0R3hhcWJYR3JsNm92VC11NXNWMU1vUFRESG5ZTEtZbkNpZzM0NW5zSmc4IiwieSI6IlFOT3RBRzd4Sm52cHlGS2lGdmJJdFBxaVBiN2VZSVMtQlRvU0YwaHM3NTgiLCJjcnYiOiJQLTI1NiJ9fQ.eyJzdWIiOiI1NDJiYWNjODAyMDUxZTdhYjBjMWZhNDAxZjAwYzhjNWJjN2Y0NzVhIiwiaWF0IjoxNzE5MjQxMTYzLCJpc3MiOiJodHRwczovL2Rldi5hdXRoei1zZXJ2ZXIxLmZvcmtib21iLmV1L2F1dGh6X3NlcnZlciIsImF1ZCI6ImRpZDpkeW5lOnNhbmRib3guc2lnbnJvb206NEtFeW1XZ0xEVWYxTE5ja2V4WTk2ZGZLejV2SDc5ZGlEZWtnTE1SOUZXcEgiLCJleHAiOjE3MTkyNDQ3NjJ9.1OhQ5FKXuh_QWxm4XMufNqFS2Zkql7bmBzfMuT8GzVEil3HzYM7dAwUo5Zl9shu-w7bEGlKkOIhXssVrMeMlXg"
	},
	"request": {
		"headers": {
			"content-length": 42,
			"Content-Type": "application/x-www-form-urlencoded",
			"DPoP": "eyJhbGciOiJFUzI1NiIsImp3ayI6eyJjcnYiOiJQLTI1NiIsImt0eSI6IkVDIiwieCI6InpKLTR1d0VWVlYxQW9GcW1yZVlzUlh1SjhGbzVHRVVUeTZ0aklBdjdUcFkiLCJ5IjoiVm9YdmEzVEpHc0o5bjlZVzV3MGplMHp6U2hmYnN3QWd6SHI1TEZCSDNsZyJ9LCJ0eXAiOiJkcG9wK2p3dCJ9.eyJodG0iOiJQT1NUIiwiaHR1IjoiaHR0cHM6Ly9kZXYuYXV0aHotc2VydmVyMS5mb3JrYm9tYi5ldS9hdXRoel9zZXJ2ZXIvdG9rZW4iLCJpYXQiOjE3MTkyNDEzMjYsImp0aSI6IkFad0VwZ2tOTlhrbllWT1JZbjNYNW9HVW1iTVp3V3d1UF9xSDNnOFRjbHcifQ.X2sO6h3GUcTu0h_qNyOsXEB2Z3qzPUd1azOJIeMmfH4zIk-Hd8sHm1RG2RaxZ3n22qSDbKjBap2G9U3Kjw5gLA"
		}
	}
}

gen_access_token.keys.json

{
	"server_data": {
		"jwk": {
			"kty": "EC",
			"crv": "P-256",
			"alg": "ES256",
			"x": "SVqB4JcUD6lsfvqMr-OKUNUphdNn64Eay60978ZlL74",
			"y": "lf0u0pMj4lGAzZix5u4Cm5CMQIgMNpkwy163wtKYVKI",
			"d": "0g5vAEKzugrXaRbgKG0Tj2qJ5lMP4Bezds1_sTybkfk"
		},
		"url": "https://valid.issuer.url",
		"authentication_url": "https://did.dyne.org/dids/"
	}
}

generate authorization code

gen_auth_code.slang

Rule unknown ignore

Given I send request 'request' and send server_data 'server' and generate authorization code and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

gen_auth_code.data.json

{
	"request": {
		"body": "client_id=did%3Adyne%3Asandbox%2Egenericissuer%3A6Cp8mPUvJmQaMxQPSnNyhb74f9Ga4WqfXCkBneFgikm5&request_uri=urn%3Aietf%3Aparams%3Aoauth%3Arequest_uri%3A1719239545ed9f269e652d207b90dec394b87225c92346023b",
        "headers": {
            "Authorization": ""
        }
    }
}

gen_auth_code.keys.json

{
	"server_data": {
		"jwk": {
			"kty": "EC",
			"crv": "P-256",
			"alg": "ES256",
			"x": "SVqB4JcUD6lsfvqMr-OKUNUphdNn64Eay60978ZlL74",
			"y": "lf0u0pMj4lGAzZix5u4Cm5CMQIgMNpkwy163wtKYVKI",
			"d": "0g5vAEKzugrXaRbgKG0Tj2qJ5lMP4Bezds1_sTybkfk"
		},
		"url": "https://valid.issuer.url",
		"authentication_url": "https://did.dyne.org/dids/"
	}
}

generate request uri

gen_request_uri.slang

Rule unknown ignore

Given I send request 'request' and send client 'client' and send server_data 'server_data' and send expires_in 'expires_in' and generate request uri and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

gen_request_uri.data.json

{
    "client": {
        "id": "did:dyne:sandbox.genericissuer:6Cp8mPUvJmQaMxQPSnNyhb74f9Ga4WqfXCkBneFgikm5",
        "clientSecret": "eyJhbGciOiJFUzI1NiJ9.eyJzdWIiOiJwaXBwbyJ9.hiVPL2JTdmcZY7Vcso95KUBEzcTGvmvQ7wlwkCo0G74Unpzny2drvLsu-HzHWyckKbRjwWox-V5gqqKeka8kEQ",
        "grants": ["authorization_code"],
        "redirectUris": ["https://Wallet.example.org/cb"],
        "scope": ["Auth1"],
        "resource": "http://issuer1.zenswarm.forkbomb.eu/credential_issuer"
    }
}

gen_request_uri.keys.json

{
	"server_data": {
		"jwk": {
			"kty": "EC",
			"crv": "P-256",
			"alg": "ES256",
			"x": "SVqB4JcUD6lsfvqMr-OKUNUphdNn64Eay60978ZlL74",
			"y": "lf0u0pMj4lGAzZix5u4Cm5CMQIgMNpkwy163wtKYVKI",
			"d": "0g5vAEKzugrXaRbgKG0Tj2qJ5lMP4Bezds1_sTybkfk"
		},
		"url": "https://valid.issuer.url",
		"authentication_url": "https://did.dyne.org/dids/"
	},
	"expires_in": 500,
	"request": {
		"body": "response_type=code&client_id=did:dyne:sandbox.genericissuer:6Cp8mPUvJmQaMxQPSnNyhb74f9Ga4WqfXCkBneFgikm5&state=xyz&code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM&code_challenge_method=S256&redirect_uri=https%3A%2F%2FWallet.example.org%2Fcb&authorization_details=%5B%7B%22type%22%3A%20%22openid_credential%22%2C%20%22credential_configuration_id%22%3A%20%22Auth1%22%2C%22locations%22%3A%20%5B%22http%3A%2F%2Fissuer1.zenswarm.forkbomb.eu%3A3100%2Fcredential_issuer%2F%22%5D%7D%5D",
		"headers": {
			"Authorization": ""
		}
	}
}

get authorization details

get_auth_details.slang

Rule unknown ignore

Given I send token 'token' and send server_data 'server' and get authorization details from token and output into 'result'

Given I have a 'string array' named 'result'
Then print data

get_auth_details.data.json

{
    "token": "eyJhbGciOiJFUzI1NiIsImp3ayI6eyJrdHkiOiJFQyIsIngiOiJ0R3hhcWJYR3JsNm92VC11NXNWMU1vUFRESG5ZTEtZbkNpZzM0NW5zSmc4IiwieSI6IlFOT3RBRzd4Sm52cHlGS2lGdmJJdFBxaVBiN2VZSVMtQlRvU0YwaHM3NTgiLCJjcnYiOiJQLTI1NiJ9fQ.eyJzdWIiOiJjYzA3N2Y4MTcwMWU3NDIxNTQ5ZmU0MjBiNDFiNTUxMjVlZDljNmZlIiwiaWF0IjoxNzE5MjQxMzI3LCJpc3MiOiJodHRwczovL2Rldi5hdXRoei1zZXJ2ZXIxLmZvcmtib21iLmV1L2F1dGh6X3NlcnZlciIsImF1ZCI6ImRpZDpkeW5lOnNhbmRib3guc2lnbnJvb206NEtFeW1XZ0xEVWYxTE5ja2V4WTk2ZGZLejV2SDc5ZGlEZWtnTE1SOUZXcEgiLCJleHAiOjE3MTkyNDQ5Mjd9.xLWyO9DkLnSU-9w_4kzmI-znQAwlYJnBbZXpKqmHNpwnFwJUdK26hmVgIQSy2HcHujKyaXX6unjmFe1P5HyK9A"
}

get_auth_details.keys.json

{
	"server": {
		"url": "https://valid.issuer.url"
	}
}

verify request parameters

ver_request_params.slang

Rule unknown ignore

Given I have a 'string' named 'client_id'
Given I have a 'string' named 'request_uri'
Given I have a 'string dictionary' named 'request'

When I set 'body' to 'client_id=' as 'string'
When I append the 'client_id' to 'body'
When I append the string '&request_uri=' to 'body'
When I append the 'request_uri' to 'body'
When I move 'body' in 'request'

Then print the 'request'

Then I send request 'request' and send server_data 'server_data' and verify request parameters

ver_request_params.data.json

{
	"client_id": "did:dyne:sandbox.genericissuer:6Cp8mPUvJmQaMxQPSnNyhb74f9Ga4WqfXCkBneFgikm5",
	"request_uri": "urn:ietf:params:oauth:request_uri:1719239545ed9f269e652d207b90dec394b87225c92346023b",
    "request": {
        "headers": {
            "Authorization": ""
        }
    }
}

ver_request_params.keys.json

{
	"server_data": {
		"jwk": {
			"kty": "EC",
			"crv": "P-256",
			"alg": "ES256",
			"x": "SVqB4JcUD6lsfvqMr-OKUNUphdNn64Eay60978ZlL74",
			"y": "lf0u0pMj4lGAzZix5u4Cm5CMQIgMNpkwy163wtKYVKI",
			"d": "0g5vAEKzugrXaRbgKG0Tj2qJ5lMP4Bezds1_sTybkfk"
		},
		"url": "https://valid.issuer.url",
		"authentication_url": "https://did.dyne.org/dids/"
	}
}

pocketbase plugin examples

create a record

create_record.slang

Rule unknown ignore

Given I connect to 'pb_address' and start pb client
Given I send my_credentials 'my_credentials' and login

Given I send create_parameters 'create_parameters' and send record_parameters 'record_parameters' and create record and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

create_record.data.json

{
	"create_parameters": {
		"collection": "organizations",
		"record": {
			"name": "Jhon org"
		}
	},
	"record_parameters": {
		"requestKey": "testCreate"
	}
}

create_record.keys.json

{
	"pb_address": "http://127.0.0.1:8090",
	"my_credentials": {
		"email": "test@test.eu",
		"password": "testtest"
	}
}

delete a record

delete_record.slang

Rule unknown ignore

Given I connect to 'pb_address' and start pb client
Given I send my_credentials 'my_credentials' and login

Given I send delete_parameters 'delete_parameters' and delete record and output into 'result'

Given I have a 'string' named 'result'
Then print the 'result'

delete_record.data.json

{
	"delete_parameters": {
		"collection": "organizations",
		"id": "q3vijjsacrn32tk"
	}
}

delete_record.keys.json

{
	"pb_address": "http://127.0.0.1:8090",
	"my_credentials": {
		"email": "test@test.eu",
		"password": "testtest"
	}
}

get one record

get_one_record.slang

Rule unknown ignore

Given I connect to 'pb_address' and start pb client

Given I send show_parameters 'show_parameters' and get one record and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

get_one_record.data.json

{
	"show_parameters": {
		"collection": "organizations",
		"id": "p7viyzsihrn52uj",
		"fields": "name"
	}
}

get_one_record.keys.json

{
	"pb_address": "http://127.0.0.1:8090"
}

get some records

get_some_records.slang

Rule unknown ignore

Given I connect to 'pb_address' and start pb client

Given I send list_parameters 'list_parameters' and get some records and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

get_some_records.data.json

{
	"list_parameters": {
		"type": "list",
		"pagination": {
			"page": 2,
			"perPage": 20
		},
		"collection": "organizations"
	}
}

get_some_records.keys.json

{
	"pb_address": "http://127.0.0.1:8090"
}

login

login.slang

Rule unknown ignore

Given I connect to 'pb_address' and start pb client

Given I send my_credentials 'my_credentials' and login and output into 'result'

Given I have a 'string' named 'result'
Then print the 'result'

login.data.json

{
	"my_credentials": {
		"email": "test@test.eu",
		"password": "testtest"
	}
}

login.keys.json

{
	"pb_address": "http://127.0.0.1:8090"
}

password reset

pw_reset.slang

Rule unknown ignore

Given I connect to 'pb_address' and start pb client
Given I send my_credentials 'my_credentials' and login

Given I send email 'email' and ask password reset and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

pw_reset.data.json

{
	"email": "test@test.eu"
}

pw_reset.keys.json

{
	"pb_address": "http://127.0.0.1:8090",
	"my_credentials": {
		"email": "test@test.eu",
		"password": "testtest"
	}
}

send request

send_request.slang

Rule unknown ignore

Given I connect to 'pb_address' and start pb client

Given I send url 'url' and send send_parameters 'send_parameters' and send request and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

send_request.data.json

{
	"url": "/api/hello/user",
	"send_parameters": {}
}

send_request.keys.json

{
	"pb_address": "http://127.0.0.1:8090"
}

start pb client

start_pb.slang

Rule unknown ignore

Given I connect to 'pb_address' and start pb client and output into 'result'
# for mobile contracts use instead
# Given I connect to 'pb_address' and start capacitor pb client and output into 'result'

Given I have a 'string' named 'result'
Then print the 'result'

start_pb.data.json

{}

start_pb.keys.json

{
	"pb_address": "http://127.0.0.1:8090"
}

update a record

update_record.slang

Rule unknown ignore

Given I connect to 'pb_address' and start pb client
Given I send my_credentials 'my_credentials' and login

Given I send update_parameters 'update_parameters' and send record_parameters 'record_parameters' and update record and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

update_record.data.json

{
	"update_parameters": {
		"id": "q3vijjsacrn32tk",
		"collection": "organizations",
		"record": {
			"name": "new value for name"
		}
	},
	"record_parameters": {
		"fields": "id, name"
	}
}

update_record.keys.json

{
	"pb_address": "http://127.0.0.1:8090",
	"my_credentials": {
		"email": "test@test.eu",
		"password": "testtest"
	}
}

qrcode plugin examples

create qr code

qr_code.slang

Rule unknown ignore

Given I send text 'text' and create qr code and output into 'result'

Given I have a 'string' named 'result'
Then print the 'result'

qr_code.data.json

{
    "text": "Hello World!"
}

qr_code.keys.json

{}

redis plugin examples

delete key from redis

delete.slang

Rule unknown ignore

Given I connect to 'redis' and send key 'key' and delete key from redis and output into 'result'

Given I have a 'number' named 'result'
Then print the 'result'

delete.data.json

{
	"key": "some key"
}

delete.keys.json

{
	"redis": "redis://localhost:6379"
}

read key from redis

read.slang

Rule unknown ignore

Given I connect to 'redis' and send key 'key' and read key from redis and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

read.data.json

{
	"key": "some key"
}

read.keys.json

{
	"redis": "redis://localhost:6379"
}

write object into key in redis

write.slang

Rule unknown ignore

Given I connect to 'redis' and send key 'key' and send object 'object' and write object into key in redis and outpuit into 'result'

Given I have a 'string' named 'result'
Then print the 'result'

write.data.json

{
	"key": "some key",
	"object": {
		"foo": "bar",
		"baz": "qux"
	}
}

write.keys.json

{
	"redis": "redis://localhost:6379"
}

shell plugin examples

execute in shell

execute.slang

Rule unknown ignore

Given I send command 'command' and execute in shell and output into 'result'

Given I have a 'string' named 'result'
Then print the 'result'

execute.data.json

{
	"command": "ls -a"
}

execute.keys.json

{}

timestamp plugin examples

fetch the local timestamp

fetch_timestamp.slang

Rule unknown ignore

Given I fetch the local timestamp in seconds and output into 'result_in_seconds'
Given I fetch the local timestamp in milliseconds and output into 'result_in_milliseconds'

Given I have a 'string' named 'result_in_seconds'
Given I have a 'string' named 'result_in_milliseconds'
Then print the 'result_in_seconds'
Then print the 'result_in_milliseconds'

fetch_timestamp.data.json

{}

fetch_timestamp.keys.json

{}

zencode plugin examples

execute zencode

execute_zencode.slang

Rule unknown ignore

Given I send keys 'keys' and send data 'data' and send script 'script' and execute zencode and output into 'result'

Given I have a 'string dictionary' named 'result'
Then print the 'result'

execute_zencode.data.json

{
	"keys": {
		"keyring": {
			"ecdh": "FJ5Esc1koLSH+9pKSdI65tcyH2HowzXMe0UdsqktmZU="
		}
	}
}

execute_zencode.keys.json

{
	"zencode": "Scenario 'ecdh': Create the public key\nGiven I have the 'keyring'\nWhen I create the ecdh public key\nThen print the 'ecdh public key'\n",
	"data": {}
}