Scribbles for my bad memory

1. use:^ (shift + 6)

This moves the cursor to the first non-blank character of the current line.

2. _ (underscore)

This also moves the cursor to the first non-blank character on the same line the cursor is on.

By the way, the 0 command moves to the absolute start of the line, including any leading whitespace.

docker network ls
then 
docker network rm networkname

Muscle Memory Makeover

Docker just streamlined Docker Compose by integrating it as a plugin. Great news, but it means us old hats need to retrain our fingers. Here's a quick fix for your .bashrc to keep things smooth:

alias docker-compose='docker compose'

MySQL in a Flash

As a programmer and Linux admin, I juggle multiple MySQL servers with different group suffixes. Typing --defaults-group-suffix every time was a drag. This handy bash function saves the day:

m() {
    if [ $# -eq 0 ]; then
        # If no arguments provided, run mysql directly
        mysql
    elif [[ "$1" == -* ]]; then
        # If first argument starts with -, pass all arguments directly to mysql
        mysql "$@"
    else
        # Otherwise, treat first argument as suffix
        local suffix=$1
        shift
        mysql --defaults-group-suffix=$suffix "$@"
    fi
}

Now, connecting to a database is as easy as:

m specific-suffix

This keeps your workflow concise and saves you precious keystrokes. Put them into you .bashrc or .zshrc now and let our life easier!

When should I use mockObject.Reset() and when should I use mockObject.Invocations.Clear()?

In the context of using a mocking framework like Moq in C# for unit testing, the choice between mockObject.Reset() and mockObject.Invocations.Clear() depends on what you want to achieve.

1. mockObject.Reset():

   • This is specific to the Moq library.
   • It resets the mock object, removing any setups or custom behavior you might have defined for that mock.
   • It does not clear recorded invocations; you can still access them after calling Reset().

   Example:

   var mock = new Mock<MyClass>();
   mock.Setup(x => x.MyMethod()).Returns("Original");
   
   // ... code using the mock ...
   
   // Reset the mock, removing setups
   mock.Reset();
   
   // Now, if you call the method, it won't use the previous setup
   var result = mock.Object.MyMethod();
   

2. mockObject.Invocations.Clear():

   • This clears the recorded invocations on the mock object.
   • It doesn't affect setups or custom behavior. It just removes the history of invocations.
   • This can be useful when you want to verify interactions or check the number of invocations without interference from previous test runs.

   Example:

   var mock = new Mock<MyClass>();
   mock.Setup(x => x.MyMethod()).Returns("Original");
   
   // ... code using the mock ...
   
   // Clear recorded invocations
   mock.Invocations.Clear();
   
   // Now, if you verify invocations, it won't consider previous calls
   mock.Verify(x => x.MyMethod(), Times.Never());

In summary:

• Use mockObject.Reset() when you want to clear setups and start fresh with the mock.
• Use mockObject.Invocations.Clear() when you want to clear the history of invocations, but keep the existing setups and behaviors.

If I set up a method with the same parameters multiple times, the last setup will take effect, right?

In most mocking frameworks, including Moq for C#, the answer is YES. Each new setup for the same method and parameters overrides any previous setups.

Here's an example using Moq:

// Setting up the method with the same parameters but different returns
mock.Setup(x => x.MyMethod()).Returns("FirstSetup");
mock.Setup(x => x.MyMethod()).Returns("SecondSetup");

// Now, if you call the method, it will return "SecondSetup"
var result = mock.Object.MyMethod();