ad hoc test

select
	<column>
from <table>
group by 1
having count(*) > 1

-- for table
{{
  config(
  	materialized="table" 
  )
}}

-- for view
{{
  config(
  	materialized="view" 
  )
}}

-- for ephemeral
{{
  config(
  	materialized="ephemeral"
  )
}}

-- for incremental
{{
  config(
  	materialized="incremental"
  )
}}

{{ 
	config(
    	materialized="incremental",
    	unique_key="page_view_id" 			-- This line is the key to replace duplicates
    )
}}

with events as (
  
	select * from {{ source('schema', 'table') }}
	{% if is_incremental() %}
    	where collector_tstamp >= ( select dateadd('day', -3, max(max_collector_tstamp)) from {{ 		this }}
    {% endif %}
    
)

dbt run		--Materialize models
dbt snapshot	--Run models in snapshot folder only
dbt deps	--Run and install dependencies
dbt run-operation required_tests	--Run tests defined in dbt_project.yml

{% snapshot mock_orders %}

{% set new_schema = target.schema + '_snapshot' %}

{{
    config(
        target_database='analytics',
        target_schema=new_schema,
        unique_key='order_id',

        strategy='timestamp',
        updated_at='updated_at'
    )
}}

select * from analytics.{{ target.schema }}.mock_orders

{% endsnapshot %}

version: 2

sources:
  - name: jaffle_shop
    description: a clone of a Postgres application database
    database: raw
    tables:
      - name: customers
        description: the raw customer data
        columns: 
          - name: id
            description: primary key of raw customer data
            tests: 
              - unique
              - not_null
      - name: orders
        description: the raw orders data
        columns: 
          - name: id
            description: primary key of raw orders data
            tests: 
              - unique
              - not_null
  

models:
  advanced_testing:
    # checks for every model under models directory should have unique and not_null test
    +required_tests: {"unique.*|not_null": 2}
    # checks for 'exclude' directory models should have unique and not_null test
    exclude:
      +required_tests: {"unique.*|not_null": 2}
	# checks for 'marts' directory models should have relationship test
    marts:
      +required_tests: {'relationship.*': 1}

{% macro generate_schema_name(custom_name, node) -%}

	{%- set default_schema = target.schema -%}
    {%- if custom_name is none -%}
    	
    	{{ default_schema }}
     
    {%- else -%}
    	
    	{{ default_schema }}_{{ custom_schema_name | trim }}
     
    {%- endif -%}

{%- endmacro -%}
    	

  public static final Randomizer<BigDecimal> BIG_DECIMAL_RANDOMIZER =
      () ->
          BigDecimal.valueOf(ThreadLocalRandom.current().nextDouble(0, 100))
              .setScale(8, RoundingMode.DOWN);

  public static EasyRandomParameters getEasyRandomParameters(int collectionSize) {
    return new EasyRandomParameters()
        .randomize(BigDecimal.class, BIG_DECIMAL_RANDOMIZER)
        .collectionSizeRange(collectionSize, collectionSize);
  }

  public static final Randomizer<BigDecimal> BIG_DECIMAL_RANDOMIZER =
      () ->
          BigDecimal.valueOf(ThreadLocalRandom.current().nextDouble(0, 100))
              .setScale(8, RoundingMode.DOWN);

let myString = "Hello, World!";
let myRegex = /Hello/;
let result = myRegex.test(myString); // result === true

const APP = (() => {
  var userData = null;
  const myURL = "http://stackoverflow.com";
  const getData = () => {
    $.ajax({
      type: "GET",
      url: myURL,
      success: obj.handleSuccess,
      error: obj.handleError,
    });
  };
  const handleError = () => {
    console.log("ERROR");
  };
  const handleSuccess = (data) => {
    userData = data;
    console.log(userData);
  };
  const render = () => {
    return "<div>some stuff</div>";
  };
  const obj = {
    getData,
    handleError,
    handleSuccess,
    render,
  };
  return obj;
})();
module.exports = APP;


const APP = require("../ajax");
describe("Ajax", () => {
  beforeEach(() => {
    jest.restoreAllMocks();
  });
  it("Data should load", () => {
    const ajaxSpy = jest.spyOn($, "ajax");
    APP.getData();
    expect(ajaxSpy).toBeCalledWith({
      type: "GET",
      url: "http://stackoverflow.com",
      success: expect.any(Function),
      error: expect.any(Function),
    });
  });
  it("should handle success", () => {
    const mUser = { userId: 1 };
    const logSpy = jest.spyOn(console, "log");
    APP.handleSuccess(mUser);
    expect(logSpy).toBeCalledWith(mUser);
  });
  it("should handle error", () => {
    const logSpy = jest.spyOn(console, "log");
    APP.handleError();
    expect(logSpy).toBeCalledWith("ERROR");
  });
});

test('Check addTodo able add todo to todoList', () => {
  document.body.innerHTML = `
    <input id="newTodoInput" />
    <button id="addTodoBtn">Add todo</button>
    <ol id="todoList"></ol>
  `;
  require('../todolist.js');

  const newTodoInput = document.getElementById('newTodoInput');
  const addTodoBtn = document.getElementById('addTodoBtn');
  const todolist = document.getElementById('todoList');

  newTodoInput.value = 'New todolist!';
  addTodoBtn.click();

  expect(todolist.innerHTML).toBe('<li>New todolist!</li>');
});

window.location.search.includes('cro_mode=qa')

// or

window.location.search.indexOf('cro_mode=qa') > -1

// finding it in cookies: 
function getCookie(name) {
  const value = `; ${document.cookie}`;
  const parts = value.split(`; ${name}=`);
  if (parts.length === 2) return parts.pop().split(';').shift();
}
//then...
getCookie('cro_mode')

//or something like ...
  const parts = document.cookie.split('cro_mode');
  if (parts.length === 2) {console.log(parts.pop().split(';').shift())}

using System.Linq;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore;


namespace TDD.Tests
{
    public class PatientTestsDbWAF<TStartup> : WebApplicationFactory<TStartup> where TStartup : class
    {

        protected override IWebHostBuilder CreateWebHostBuilder()
        {
            return WebHost.CreateDefaultBuilder()
                .UseStartup<TStartup>();
        }
        protected override void ConfigureWebHost(IWebHostBuilder builder)
        {
            builder.ConfigureServices(async services =>
           {
               // Remove the app's DbContext registration.
               var descriptor = services.SingleOrDefault(
                      d => d.ServiceType ==
                          typeof(DbContextOptions<DataContext>));

               if (descriptor != null)
               {
                   services.Remove(descriptor);
               }

               // Add DbContext using an in-memory database for testing.
               services.AddDbContext<DataContext>(options =>
                  {
                      // Use in memory db to not interfere with the original db.
                      options.UseInMemoryDatabase("PatientTestsTDD.db");
                  });
           });
        }
    }
}