🥋 Karate 🥰 ❄️ Snowflake

Feature: Burger 🍔 feature

  Background:
    Given input topic
      | topic     | alias        | key_type | value_type |
      | bread     | bread-in     | string   | string     |
      | vegetable | vegetable-in | string   | string     |
      | meat      | meat-in      | string   | string     |
    And output topic
      | topic  | alias      | key_type | value_type | readTimeoutInSecond |
      | burger | burger-out | string   | string     | 5                   |
    And var uuid = call function: uuid

  Scenario Outline: Burger Factory
    When records with key and value are sent
      | topic_alias  | key        | value       |
      | bread-in     | 🧑‍🍳_${uuid} | <bread>     |
      | vegetable-in | 🧑‍🍳_${uuid} | <vegetable> |
      | meat-in      | 🧑‍🍳_${uuid} | <meat>      |
      
    Then expected records
      | topic_alias | key        | value  |
      | burger-out  | 🧑‍🍳_${uuid} | result |

    And assert result $ == "<output>"

    Examples:
      | bread | vegetable | meat | output       |
      | 🍞    | 🍅        | 🥩   | 🍔           |
      | 🍞    | 🍅        | 🍗   | 🍔           |
      | 🍞    | 🍅        | 🐟   | 🍔           |
      | 🍞    | 🥕        | 🥩   | 🍞 + 🥕 + 🥩 |

Feature: karate 'hello world' example
  
  Scenario: create and retrieve a cat
    Given url 'http://myhost.com/v1/cats'
    And request { name: 'Billie' }
    When method post
    Then status 201
    And match response == { id: '#notnull', name: 'Billie' }
    
    Given path response.id
    When method get
    Then status 200

Feature: SELECT V1
  Background:
    * url "https://<SNOWFLAKE_ACCOUNT>.snowflakecomputing.com/api/v2"
    * string jwtToken = karate.exec("snow connection generate-jwt --silent --account <SNOWFLAKE_ACCOUNT> --user <SNOWFLAKE_USER> --private-key-file <SNOWFLAKE_USER_PEM>")
    * header Content-Type = "application/json"
    * header Accept = "application/json"
    * header Authorization = "Bearer " + jwtToken
    * header User-Agent = "<MY_APP_IT>"
    * header X-Snowflake-Authorization-Token-Type = "KEYPAIR_JWT"

  Scenario: Select 1 cutter
    Given path "statements"
    And text payload =
        """
        {
          "statement": "SELECT SERIAL_NUMBER, CUTTER_TYPE FROM CUTTER WHERE SERIAL_NUMBER='MY_VECTOR'",
          "timeout": 60,
          "role": "<SNOWFLAKE_ROLE>",
          "warehouse": "<SNOWFLAKE_WAREHOUSE>",
          "database": "<SNOWFLAKE_DATABASE>",
          "schema": "<SNOWFLAKE_SCHEMA>"
        }
        """
    When request payload
    And method post
    Then status 200
    And match response.resultSetMetaData.numRows == 1
    And match response.resultSetMetaData.rowType[0].name == "SERIAL_NUMBER"
    And match response.resultSetMetaData.rowType[1].name == "CUTTER_TYPE"
    And match response.data[0][0] == "MY_VECTOR"
    And match response.data[0][1] == "VECTOR"

function fn() {
  const mySuperFunction = (input) => input.toUpperCase();
  return {
    "projectName": "mySuperProject",
    "myFunction": mySuperFunction
  };
}

Feature: SELECT V2
  Background:
    * json cliConfig = read('classpath:cli-config.json')
    * json snowflakeConfig = read('classpath:snowflake-config.json')
    * string jwt = snowflake.cli.generateJwt(cliConfig)
    * json restConfig = ({jwt, cliConfig, snowflakeConfig})

  Scenario: Select 1 cutter
    Given text statement =
    """
      SELECT SERIAL_NUMBER, CUTTER_TYPE
      FROM CUTTER
      WHERE SERIAL_NUMBER='MY_VECTOR'
    """
    And def response = snowflake.rest.runSql({...restConfig, statement})
    And table expectedData
      | SERIAL_NUMBER | CUTTER_TYPE |
      | "MY_VECTOR"   | "VECTOR"    |
    And match response.data == expectedData

Feature: Demo
  Background:
    * json cliConfig = snowflake.cliConfigFromEnv
    * string jwt = snowflake.cli.generateJwt(cliConfig)
    * json restConfig = ({jwt, cliConfig})
    * string clientId = "😋_"+base.random.uuid()
    * def insert = (table, value) => "INSERT INTO "+table+"(CLIENT_ID, VALUE) VALUES ('"+clientId+"','"+value+"')"

  Scenario Outline: Burger Factory - <bread> + <vegetable> + <meat> = <output>
    Given table inserts
      | table       | value         | config                     |
      | "BREAD"     | "<bread>"     | snowflakeConfigs.BREAD     |
      | "VEGETABLE" | "<vegetable>" | snowflakeConfigs.VEGETABLE |
      | "MEAT"      | "<meat>"      | snowflakeConfigs.MEAT      |
    And json responses = karate.map(inserts, (row) => snowflake.rest.runSql({...restConfig, snowflakeConfig: row.config, statement: insert(row.table, row.value)}).status)
    And match each responses == "OK"

    When json dbtResult = dbt.cli.run({})
    And match dbtResult.status == "OK"
    And match dbtResult.output contains "Completed successfully"

    Then string select = "SELECT VALUE FROM BURGER WHERE CLIENT_ID='"+clientId+"'"
    And json response = snowflake.rest.runSql({...restConfig, snowflakeConfig: snowflakeConfigs.BURGER, statement: select })
    And match response.data == [ { "VALUE" : "<output>" } ]

    Examples:
      | bread | vegetable | meat | output       |
      | 🍞    | 🍅        | 🥩   | 🍔           |
      | 🍞    | 🍅        | 🍗   | 🍔           |
      | 🍞    | 🍅        | 🐟   | 🍔           |
      | 🍞    | 🥕        | 🥩   | 🍞 + 🥕 + 🥩 |

Feature: Demo - Clone Schemas
  Background:
    * json cliConfig = snowflake.cliConfigFromEnv
    * string jwt = snowflake.cli.generateJwt(cliConfig)
    * json restConfig = ({jwt, cliConfig, snowflakeConfig: snowflakeConfigs.BREAD})
    * string clientId = "😋_"+base.random.uuid()
    * def insert = (table, value) => "INSERT INTO "+table+"(CLIENT_ID, VALUE) VALUES ('"+clientId+"','"+value+"')"
    * json cloneResult = cloneSnowflakeConfigs(restConfig)
    * configure afterScenario = function(){ dropSnowflakeConfigs(restConfig, cloneResult.snowflakeConfigs) }

  Scenario Outline: Burger Factory - <bread> + <vegetable> + <meat> = <output>
    Given table inserts
      | table       | value         | config                                 |
      | "BREAD"     | "<bread>"     | cloneResult.snowflakeConfigs.BREAD     |
      | "VEGETABLE" | "<vegetable>" | cloneResult.snowflakeConfigs.VEGETABLE |
      | "MEAT"      | "<meat>"      | cloneResult.snowflakeConfigs.MEAT      |
    And json responses = karate.map(inserts, (row) => snowflake.rest.runSql({...restConfig, snowflakeConfig: row.config, statement: insert(row.table, row.value)}).status)
    And match each responses == "OK"

    When json dbtResult = dbt.cli.run({env:cloneResult.env})
    And match dbtResult.status == "OK"
    And match dbtResult.output contains "Completed successfully"
    
    Then string select = "SELECT VALUE FROM BURGER WHERE CLIENT_ID='"+clientId+"'"
    And json response = snowflake.rest.runSql({...restConfig, snowflakeConfig: cloneResult.snowflakeConfigs.BURGER, statement: select })
    And match response.data == [ { "VALUE" : "<output>" } ]

    Examples:
      | bread | vegetable | meat | output       |
      | 🍞    | 🍅        | 🥩   | 🍔           |
      | 🍞    | 🍅        | 🍗   | 🍔           |
      | 🍞    | 🍅        | 🐟   | 🍔           |
      | 🍞    | 🥕        | 🥩   | 🍞 + 🥕 + 🥩 |