ryanermita

Optimistic Locking assumes that a database transaction conflict is very rare to happen. It uses a version number of the record to track the changes. It raise an error when other user tries to update the record while it is lock.

usage

Just add a lock_version column to the table you want to place the lock and Rails will automatically check this column before updating the record.

Pessimistic locking assumes that database transaction conflict is very likely to happen. It locks the record until the transaction is done. If the record is currently lock and the other user make a transaction, that second transaction will wait until the lock in first transaction is release.

usage

ryanermita

import redis  # install redis via pip > `python -m pip install redis`
import json

# Instantiate redis connection with your local redis instance.
redis_connection = redis.StrictRedis(host="localhost", port=int(6379),
                                     decode_responses=True)

"""
Caching simple object (flat and one dimentional object) as redis hash.
"""

ryanermita

from unittest import TestCase, mock
import simple

class TestSimple(TestCase):

    @mock.patch('simple.pymysql', autospec=True)
    def test_get-data(self, mock_pymysql):
        mock_cursor = mock.MagicMock()
        test_data = [{'password': 'secret', 'id': 1}]
        mock_cursor.fetchall.return_value = test_data

ryanermita

import requests
import json
import base64

CUSTOMER_IO_SITE_ID='<SITE ID>'
CUSTOMER_IO_API_KEY='<API KEY>'
CUSTOMER_IO_CREDS = f'{CUSTOMER_IO_SITE_ID}:{CUSTOMER_IO_API_KEY}'
CUSTOMER_IO_ENCODED_CREDS = base64.b64encode(CUSTOMER_IO_CREDS.encode()).decode() 

def send_verification_email():

ryanermita

import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_exchange', exchange_type='direct')
channel.queue_declare(queue='direct_queue', durable=True)
channel.queue_bind(exchange='direct_exchange', queue="direct_queue", routing_key="direct.routing.key")

ryanermita

import pika
import time

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_exchange', exchange_type='direct')
channel.queue_declare(queue='direct_queue', durable=True)
channel.queue_bind(exchange='direct_exchange', queue="direct_queue", routing_key="direct.routing.key")

ryanermita

import unittest
from unittest.mock import patch


class MyDummyClass:

    def test_dummy_function(self):
        return "hello"

ryanermita

import unittest
from unittest.mock import patch


class MyDummyClass:

    def __init__(self):
        self.my_dummy_attribute = "yey!"

    def test_dummy_function(self):

ryanermita

    __lt__: NotImplemented
    __gt__: NotImplemented
    __le__: NotImplemented
    __ge__: NotImplemented
    __int__: 1
    __contains__: False
    __len__: 0
    __iter__: iter([])
    __exit__: False
    __complex__: 1j

ryanermita

dict_object = {
	"name": "John Doe",
	"social_media_accounts": ["facebook", "twitter", "Instagram"],
	"language_proficiency": {
		"Python": "9/10", 
		"Javascript": "7/10",
		"Ruby": "8/10"
	}
}