DEV Community: FaithInErrorsZORO

Writing tests in python?

FaithInErrorsZORO — Wed, 14 Oct 2026 02:28:10 +0000

from colorama import init, Fore
from duration import *

def print_pass(the_data, i):
print(f'{Fore.GREEN}Test {i} with {the_data} passed')

def print_fail(the_data, i):
print(f'''{Fore.RED}*** Test {i} with {the_data} failed.''')

def print_tests():
_test_default = Duration(60)
_test_minutes = Duration(10, "m")
_test_hours = Duration(2, "h")
_test_sec = Duration(120, "s")

print('''

Test #1 - simple declarations
-----------------------------''')
test_objects = (
_test_default,
_test_minutes,
_test_hours,
_test_sec
)

test_print_out = (
    "60.00 s",
    "600.00 s",
    "7200.00 s",
    "120.00 s"
)

test_repr_out = (
    "Duration(60.00, 's')",
    "Duration(10.00, 'm')",
    "Duration(2.00, 'h')",
    "Duration(120.00, 's')"
)

for i, test_obj in enumerate(test_objects):
    try:
        assert str(test_obj) == test_print_out[i], f'Expected {test_print_out[i]} received {str(test_obj)}'
        print_pass(f'print of {test_obj}', i+1)
        assert repr(test_obj) == test_repr_out[i], f'Expected {test_repr_out[i]} received {repr(test_obj)}'
        print_pass(f'repr of {repr(test_obj)}', i+1)

    except AssertionError as test_data:
        print_fail(test_data, i+1)
        continue

def add_tests():
print('''

Test #2 - Addition
------------------''')
_test_default = Duration(60)
_test_minutes = Duration(5, "m")
_test_hours = Duration(1, "h")
_test_list = [Duration(10), Duration(2, 'm'), Duration(1, 'h')]
_test_inc = Duration(60)

test_objects = (
    _test_default + _test_minutes,
    _test_default + 30,
    sum(_test_list),
    15 + _test_minutes
)

test_add_out = (
    "Duration(360.00, 's')",
    "Duration(90.00, 's')",
    "Duration(3730.00, 's')",
    "Duration(5.25, 'm')"
)

for i, test_obj in enumerate(test_objects):
    try:
        assert repr(test_obj) == test_add_out[i], f'Expected {test_add_out[i]} received {repr(test_obj)}'
        print_pass(f'print of {repr(test_obj)}', i+1)

    except AssertionError as test_data:
        print_fail(test_data, i+1)
        continue

_test_inc += 30
try:
    assert repr(_test_inc) == "Duration(90.00, 's')", f'Expected Duration(90.00, s) received {repr(_test_inc)}'
    print_pass(f'Incremental test of {repr(_test_inc)}', 1)
except AssertionError as test_data:
    print_fail(test_data, 1)

def sub_tests():
print('''

Test #3 - Test all subtraction cases
------------------------------------''')
_test_default = Duration(120)
_test_minutes = Duration(1, "m")
_test_dec = Duration(100)

test_objects = (
    _test_default - _test_minutes,
    _test_default - 30
)

test_sub_out = (
    "Duration(60.00, 's')",
    "Duration(90.00, 's')"
)

try:
    reverse_sub = 200 - Duration(60, "s")
    assert repr(reverse_sub) == "Duration(140.00, 's')", \
        f"Expected Duration(140.00, 's') received {repr(reverse_sub)}"
    print_pass(f'reverse subtraction: {repr(reverse_sub)}', 6)
except AssertionError as test_data:
    print_fail(test_data, 6)

for i, test_obj in enumerate(test_objects):
    try:
        assert repr(test_obj) == test_sub_out[i], f'Expected {test_sub_out[i]} received {repr(test_obj)}'
        print_pass(f'print of {repr(test_obj)}', i+1)

    except AssertionError as test_data:
        print_fail(test_data, i+1)
        continue

_test_dec -= 40
try:
    assert repr(_test_dec) == "Duration(60.00, 's')", f'Expected Duration(60.00, s) received {repr(_test_dec)}'
    print_pass(f'Decremental test of {repr(_test_dec)}', 1)
except AssertionError as test_data:
    print_fail(test_data, 1)

def comp_tests():
print('''

Test #4 - Test comparisons between Duration objects
--------------------------''')

_test_comp1 = Duration(60)
_test_comp2 = Duration(1, "m")
_test_comp7 = Duration(100)
_test_comp8 = Duration(101)

count = 1
try:
    assert _test_comp1 == _test_comp2, f'Equality tested failed for {repr(_test_comp1)} and {repr(_test_comp2)}'
    print_pass(f'comparison: {repr(_test_comp1)} = {repr(_test_comp2)} ', count)
except AssertionError as test_data:
    print_fail(test_data, count)

count += 1
try:
    assert not (_test_comp7 > _test_comp8), f'Greater than test failed for {repr(_test_comp7)} and {repr(_test_comp8)}'
    print_pass(f'comparison: {repr(_test_comp7)} not > {repr(_test_comp8)} ', count)
    assert _test_comp7 < _test_comp8, f'Less than test failed for {repr(_test_comp7)} and {repr(_test_comp8)}'
    print_pass(f'comparison: {repr(_test_comp7)} < {repr(_test_comp8)} ', count)
except AssertionError as test_data:
    print_fail(test_data, count)

def exception_tests():
print('''

Test #5 - Test Exceptions
-------------------------''')
count = 1
try:
Duration("abc")
print_fail(f'Value error not thrown when value is string', count)
except ValueError as msg:
try:
assert str(msg) == "Value must be a number", f'Value error does not have correct message. Received {msg}'
print_pass(f'Value error thrown with message: {msg} as expected', count)
except AssertionError as test_data:
print_fail(test_data, count)
count += 1

try:
    Duration(-10)
    print_fail(f'Less than zero exception not thrown when value is negative', count)
except DurationLessThanZeroException as msg:
    try:
        assert str(msg) == "Duration cannot be negative", f'Exception does not have correct message. Received {msg}'
        print_pass(f'Negative-value error thrown with message: {msg} as expected', count)
    except AssertionError as test_data:
        print_fail(test_data, count)

count += 1
try:
    Duration(10, "abc")
    print_fail(f'Incorrect unit exception not thrown', count)
except TimeUnitNotDefinedException as msg:
    try:
        assert str(msg) == "Unit cannot be used", f'Exception does not have correct message. Received {msg}'
        print_pass(f'Unit error thrown with message: {msg} as expected', count)
    except AssertionError as test_data:
        print_fail(test_data, count)

if name == "main":
init(autoreset=True)
print_tests()
add_tests()
sub_tests()
comp_tests()
exception_tests()

Dice comprehension list in python

FaithInErrorsZORO — Wed, 14 Oct 2026 02:26:49 +0000

import random

def main():
# Two Dice
dice_combos = [(d1, d2) for d1 in range(1, 7) for d2 in range(1, 7)]
dice_rolled = [random.choice(dice_combos) for _ in range(100)]
sum_of_rolls = {i: 0 for i in range(2, 13)}

for roll in dice_rolled:
    sum_of_rolls[sum(roll)] += 1
print("2 Dice Rolled:", dice_rolled[:5], "...") # Preview
print("2 Dice Sums:", sum_of_rolls)

# Three Dice
dice_combos_3 = [(d1, d2, d3) for d1 in range(1, 7) for d2 in range(1, 7) for d3 in range(1, 7)]
dice_rolled_3 = [random.choice(dice_combos_3) for _ in range(100)]
sum_of_rolls_3 = {i: 0 for i in range(3, 19)}

for roll in dice_rolled_3:
    sum_of_rolls_3[sum(roll)] += 1
print("3 Dice Sums:", sum_of_rolls_3)

if name == "main":
main()

Hello world app with dictionaries and comprehension lists in python.

FaithInErrorsZORO — Wed, 14 Oct 2026 02:26:16 +0000

def add_entry(phone_book):
name = input("Enter name: ").title()
if name in phone_book:
print("There is already an entry for a student by that name, try another name")
else:
phone = input("Enter phone number: ")
phone_book[name] = phone

def search_entry(phone_book):
name = input("Enter name: ").title()
if name in phone_book:
print(f"{name}: {phone_book[name]}")
else:
print("There is no entry for a student by that name.")

def search_prefix(phone_book):
prefix = input("Enter starting letters: ").title()
matches = {k: v for k, v in phone_book.items() if k.startswith(prefix)}
if not matches:
print("No matches found.")
else:
for k in sorted(matches.keys()):
print(f"{k}: {matches[k]}")

def print_book(phone_book):
for key in sorted(phone_book.keys()):
print(f"{key}: {phone_book[key]}")

def main():
phone_book = {}
while True:
choice = input("\n1-Add, 2-Search, 3-Search Prefix, 4-Print All, 5-Exit: ")
if choice == '1': add_entry(phone_book)
elif choice == '2': search_entry(phone_book)
elif choice == '3': search_prefix(phone_book)
elif choice == '4': print_book(phone_book)
elif choice == '5': break
else: print("Error: Invalid choice.")

if name == "main":
main()

Reading and writing with files in python?

FaithInErrorsZORO — Wed, 14 Oct 2026 02:25:09 +0000

def sum_column(filename):
total, error_count = 0, 0
with open(filename, 'r') as file:
for line in file:
try:
total += int(line.strip())
except ValueError:
error_count += 1
return total, error_count

def sum_all(filename):
total, error_count = 0, 0
with open(filename, 'r') as file:
for line in file:
for num in line.split():
try:
total += int(num)
except ValueError:
error_count += 1
return total, error_count

def main():
filename = input("Enter a file name: ")
operation = input("Enter operation (sum_column or sum_all): ")

try:
    if operation == "sum_column":
        result, errors = sum_column(filename)
        print(f"Sum: {result}, Errors: {errors}")
    elif operation == "sum_all":
        result, errors = sum_all(filename)
        print(f"Sum: {result}, Errors: {errors}")
    else:
        print("Invalid operation entered.")
except FileNotFoundError:
    print(f"User-friendly message: The file '{filename}' does not exist.")

if name == "main":
main()

Python classes ? being pythonic

FaithInErrorsZORO — Wed, 14 Oct 2026 02:24:37 +0000

class MassLessThanZeroException(Exception):
pass

class UnitNotDefinedException(Exception):
pass

class Mass:
_conversion = {
'mg': 0.000001,
'g': 0.001,
'kg': 1,
'lb': 0.453592,
'oz': 0.02835,
'stone': 6.35029
}

def __init__(self, value, unit='kg'):
    if not isinstance(value, (int, float)) or isinstance(value, bool):
        raise ValueError("Value must be a number")
    if value < 0:
        raise MassLessThanZeroException("Value cannot be negative")
    if unit not in self._conversion:
        raise UnitNotDefinedException("Unit cannot be used")

    self.value = value
    self.unit = unit

def convert_to_kg(self):
    return self.value * Mass._conversion[self.unit]

def __str__(self):
    return f"{self.convert_to_kg():.2f} kg"

def __repr__(self):
    return f"Mass({self.value:.2f}, '{self.unit}')"

def __add__(self, other):
    if isinstance(other, (int, float)):
        total = self.convert_to_kg() + other
    else:
        total = self.convert_to_kg() + other.convert_to_kg()
    return Mass(total / Mass._conversion[self.unit], self.unit)

def __iadd__(self, other):
    return self + other

def __radd__(self, other):
    return self + other

def __sub__(self, other):
    if isinstance(other, (int, float)):
        total = self.convert_to_kg() - other
    else:
        total = self.convert_to_kg() - other.convert_to_kg()
    return Mass(max(0, total) / Mass._conversion[self.unit], self.unit)

def __isub__(self, other):
    return self - other

def __rsub__(self, other):
    if isinstance(other, (int, float)):
        total = other - self.convert_to_kg()
    else:
        total = other.convert_to_kg() - self.convert_to_kg()
    return Mass(max(0, total) / Mass._conversion[self.unit], self.unit)

def __lt__(self, other):
    return self.convert_to_kg() < other.convert_to_kg()

def __gt__(self, other):
    return self.convert_to_kg() > other.convert_to_kg()

def __eq__(self, other):
    return abs(self.convert_to_kg() - other.convert_to_kg()) < 0.01

getting into python functional programming any thoughts ?

FaithInErrorsZORO — Wed, 14 Oct 2026 02:19:00 +0000

from functools import reduce

1. CUSTOM DISCOUNT CALCULATOR (Scenario: Retail Discounts)

def make_discount_calculator(discount_rate):
def calculate_discount(price):
return price * discount_rate
return calculate_discount

2. CONVERT TO A PURE FUNCTION (Scenario: Applying Wholesale Markup)

def apply_markup(costs):
if not costs:
return []
return [costs[0] * 1.25] + apply_markup(costs[1:])

3. ID NUMBER GENERATOR (Scenario: Database ID Assignment)

def make_id_tracker(current_id):
def get_next_id():
return current_id, make_id_tracker(current_id + 1)
return get_next_id

4. REWRITE WITH YIELD (Scenario: Database ID Assignment Generator)

def make_id_tracker_2(current_id):
while True:
yield current_id
current_id += 1

5. GAME SCORES REPORT (Scenario: Multiplayer Match Results)

def process_scores(scores):
qualifying_scores = filter(lambda x: x >= 50, scores)
buffed_scores = map(lambda x: x + 10, qualifying_scores)
total_team_score = reduce(lambda x, y: x + y, buffed_scores, 0)
return total_team_score

6. INVENTORY TRACKER SIMULATION (Scenario: Warehouse Stock)

def make_inventory(stock_level):
def inventory(action, quantity):
if action == "restock":
return make_inventory(stock_level + quantity)
elif action == "sell":
return make_inventory(stock_level - quantity)
elif action == "audit":
return stock_level, make_inventory(stock_level)
else:
raise ValueError("Unknown action")
return inventory

7. EVENT PROCESSING WITHOUT LOOPS (Scenario: Applying Buffs to Player Stats)

def map_recursively(operation, elements):
if not elements:
return []
return [operation(elements[0])] + map_recursively(operation, elements[1:])

8. IMAGE PROCESSING PIPELINE (Scenario: Batch Image Resizing)

def compose_funcs(f, g):
return lambda x: f(g(x))

def make_image_processor():
downscale = lambda pixels: pixels * 0.5
apply_brightness = lambda pixels: pixels + 15
compress = lambda pixels: round(pixels, 0)
return compose_funcs(compress, compose_funcs(apply_brightness, downscale))

9. TEXT FORMATTING PIPELINE (Scenario: Chat Filter)

def strip_vowels(word):
if not word:
return ""
char = word[0]
rest = strip_vowels(word[1:])
if char.lower() in "aeiou":
return rest
return char + rest

def chain_processors(routines):
return lambda data: reduce(lambda current_val, routine: routine(current_val), routines, data)

10. FLATTENING DEPARTMENT DATA (Scenario: Corporate Org Chart)

def unnest_structure(hierarchy):
if not hierarchy:
return []
if isinstance(hierarchy[0], list):
return unnest_structure(hierarchy[0]) + unnest_structure(hierarchy[1:])
return [hierarchy[0]] + unnest_structure(hierarchy[1:])

def main():
print("--- 1. CUSTOM DISCOUNT CALCULATOR ---")
student_discount = make_discount_calculator(0.20)
print(f"20% discount on $200: ${student_discount(200)}")

print("\n--- 2. CONVERT TO A PURE FUNCTION ---")
costs = [100, 200, 50]
print(f"Original costs: {costs}")
print(f"With markup: {apply_markup(costs)}")

print("\n--- 3. ID NUMBER GENERATOR ---")
tracker = make_id_tracker(1000)
id1, tracker = tracker()
id2, tracker = tracker()
print(f"Generated IDs: {id1}, {id2}")

print("\n--- 4. REWRITE WITH YIELD ---")
tracker_gen = make_id_tracker_2(1000)
print(f"Generated IDs (yield): {next(tracker_gen)}, {next(tracker_gen)}")

print("\n--- 5. GAME SCORES REPORT ---")
scores = [40, 80, 55, 30, 90]
print(f"Processed Total Score: {process_scores(scores)}")

print("\n--- 6. INVENTORY TRACKER SIMULATION ---")
inv = make_inventory(500)
inv = inv("restock", 200)
inv = inv("sell", 50)
current_stock, inv = inv("audit", 0)
print(f"Current Inventory Stock: {current_stock}")

print("\n--- 7. EVENT PROCESSING WITHOUT LOOPS ---")
double_buff = lambda x: x * 2
stats = [10, 20, 30]
print(f"Buffed Stats: {map_recursively(double_buff, stats)}")

print("\n--- 8. IMAGE PROCESSING PIPELINE ---")
pipeline = make_image_processor()
print(f"Processed Pixel Value (from 100): {pipeline(100)}")

print("\n--- 9. TEXT FORMATTING PIPELINE ---")
strip_whitespace = lambda s: s.strip()
lowercase = lambda s: s.lower()
text_pipeline = chain_processors([strip_whitespace, lowercase, strip_vowels])
print(f"Processed Text: {text_pipeline('  HELLO World  ')}")

print("\n--- 10. FLATTENING DEPARTMENT DATA ---")
org_chart = ["Executive", ["Engineering", ["Frontend", "Backend"]], "HR"]
print(f"Flattened Org Chart: {unnest_structure(org_chart)}")

if name == "main":
main()

Some asp.net fizz buzz testing

FaithInErrorsZORO — Wed, 30 Sep 2026 02:28:17 +0000

using System;
using System.Collections.Generic;
using PartA.Models;
using Xunit;

namespace PartA.Tests
{
public class FizzBuzzTests
{
private readonly FizzBuzz _fizzBuzz;

    public FizzBuzzTests()
    {
        _fizzBuzz = new FizzBuzz();
    }

    // 1st test - Returns list 1 to 100[cite: 3]
    [Fact]
    public void GetList_ReturnsList1To100_WhenNoParametersPassed()
    {
        // ACT
        List<string> result = _fizzBuzz.getList();

        // ASSERT
        Assert.Equal(100, result.Count);
        Assert.Equal("1", result[0]);
        Assert.Equal("Buzz", result[99]); // Number 100
    }

    // 2nd test - Fizz for 3 multiples[cite: 3]
    [Fact]
    public void GetList_ReturnsFizz_ForMultiplesOfThree()
    {
        // ACT
        List<string> result = _fizzBuzz.getList();

        // ASSERT
        Assert.Equal("Fizz", result[2]); // Index 2 represents number 3
        Assert.Equal("Fizz", result[8]); // Index 8 represents number 9
    }

    // 3rd test - Buzz for 5 multiples[cite: 3]
    [Fact]
    public void GetList_ReturnsBuzz_ForMultiplesOfFive()
    {
        // ACT
        List<string> result = _fizzBuzz.getList();

        // ASSERT
        Assert.Equal("Buzz", result[4]); // Index 4 represents number 5
        Assert.Equal("Buzz", result[9]); // Index 9 represents number 10
    }

    // 4th test - FizzBuzz for 3&5[cite: 3]
    [Fact]
    public void GetList_ReturnsFizzBuzz_ForMultiplesOfThreeAndFive()
    {
        // ACT
        List<string> result = _fizzBuzz.getList();

        // ASSERT
        Assert.Equal("FizzBuzz", result[14]); // Index 14 represents number 15
        Assert.Equal("FizzBuzz", result[29]); // Index 29 represents number 30
    }

    // 5th test - Upper limit with default[cite: 3]
    [Fact]
    public void GetList_RespectsUpperLimit_WhenPassed()
    {
        // ARRANGE
        int bramUpperLimit = 10;

        // ACT
        List<string> result = _fizzBuzz.getList(bramUpperLimit);

        // ASSERT
        Assert.Equal(10, result.Count);
        Assert.Equal("Buzz", result[9]); // Number 10
    }

    // 6th test - Lower limit with default[cite: 3]
    [Fact]
    public void GetList_RespectsLowerLimit_WhenPassed()
    {
        // ARRANGE
        int bramUpperLimit = 20;
        int bramLowerLimit = 15;

        // ACT
        List<string> result = _fizzBuzz.getList(bramUpperLimit, bramLowerLimit);

        // ASSERT
        Assert.Equal(6, result.Count); // 15, 16, 17, 18, 19, 20
        Assert.Equal("FizzBuzz", result[0]); // Number 15
    }

    // 7th test - Argument out of Range exception[cite: 3]
    [Fact]
    public void GetList_ThrowsArgumentOutOfRangeException_WhenLowerGreaterThanUpper()
    {
        // ARRANGE
        int bramUpperLimit = 10;
        int bramLowerLimit = 20;

        // ACT & ASSERT
        Assert.Throws<ArgumentOutOfRangeException>(() => _fizzBuzz.getList(bramUpperLimit, bramLowerLimit));
    }
}

}

Getting into C# testing

FaithInErrorsZORO — Wed, 30 Sep 2026 02:18:23 +0000

Here are the tests I am running for a school registration system : using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using SportsWeb.Models;
using Xunit;

namespace SportsWeb.Tests.Models
{
public class RegistrationViewModelValidationTests
{
private static IList Validate(object model)
{
var ctx = new ValidationContext(model, serviceProvider: null, items: null);
var results = new List();
Validator.TryValidateObject(model, ctx, results, validateAllProperties: true);
return results;
}

    [Fact]
    public void Missing_Season_IsInvalid()
    {
        // ARRANGE: Simulating a missing drop-down selection
        var vm = new RegistrationViewModel
        {
            AthleteName = "Bram",
            Season = null, 
            Sport = "Basketball"
        };

        // ACT
        var results = Validate(vm);

        // ASSERT
        Assert.Contains(results, r => r.MemberNames.Contains(nameof(RegistrationViewModel.Season)));
    }

    [Fact]
    public void Missing_Sport_IsInvalid()
    {
        // ARRANGE: Simulating no radio button being selected
        var vm = new RegistrationViewModel
        {
            AthleteName = "Bram",
            Season = "Fall",
            Sport = null 
        };

        var results = Validate(vm);

        Assert.Contains(results, r => r.MemberNames.Contains(nameof(RegistrationViewModel.Sport)));
    }

    [Fact]
    public void Valid_RegistrationModel_Passes()
    {
        // ARRANGE
        var vm = new RegistrationViewModel
        {
            AthleteName = "Bram",
            Season = "Winter",
            Sport = "Basketball"
        };

        // ACT
        var results = Validate(vm);

        // ASSERT
        Assert.Empty(results);
    }
}

}

using System;
using SportsWeb.Models;
using SportsWeb.Services;
using Xunit;

namespace SportsWeb.Tests.Services
{
public class RegistrationServiceTests
{
private readonly IRegistrationService _service;

    public RegistrationServiceTests()
    {
        // Testing the concrete service implementation
        _service = new RegistrationService(); 
    }

    [Fact]
    public void CalculateFee_ReturnsStandardRate_ForWinterBasketball()
    {
        // Arrange
        var vm = new RegistrationViewModel { Season = "Winter", Sport = "Basketball" };

        // Act
        decimal fee = _service.CalculateFee(vm);

        // Assert
        Assert.Equal(150m, fee);
    }

    [Theory]
    [InlineData("Summer", "Soccer", 100)]
    [InlineData("Spring", "Tennis", 120)]
    public void CalculateFee_ReturnsCorrectRates_ForAllSeasons(string season, string sport, decimal expectedFee)
    {
        // Arrange
        var vm = new RegistrationViewModel { Season = season, Sport = sport };

        // Act
        decimal fee = _service.CalculateFee(vm);

        // Assert
        Assert.Equal(expectedFee, fee);
    }
}

}

here are the controller tests : using Microsoft.AspNetCore.Mvc;
using Moq;
using SportsWeb.Controllers;
using SportsWeb.Models;
using SportsWeb.Services;
using Xunit;

namespace SportsWeb.Tests.Controllers
{
public class RegistrationControllerTests
{
private readonly Mock _mockService;
private readonly RegistrationController _controller;

    public RegistrationControllerTests()
    {
        _mockService = new Mock<IRegistrationService>();
        _controller = new RegistrationController(_mockService.Object);
    }

    [Fact]
    public void CreatePost_InvalidModel_ReturnsSameView()
    {
        // ARRANGE
        // Simulate ASP.NET Core catching a missing radio button selection
        _controller.ModelState.AddModelError("Sport", "Please select a sport.");

        var vm = new RegistrationViewModel { AthleteName = "Bram", Season = "Fall", Sport = null };

        // ACT
        var result = _controller.Create(vm) as ViewResult;

        // ASSERT
        Assert.NotNull(result);
        Assert.False(_controller.ModelState.IsValid);
        Assert.Same(vm, result.Model); // Ensure the form is sent back to the user with their inputs intact

        // Verify the database/service was NOT called since the model was invalid
        _mockService.VerifyNoOtherCalls(); 
    }

    [Fact]
    public void CreatePost_ValidModel_CallsServiceAndRedirects()
    {
        // ARRANGE
        var vm = new RegistrationViewModel { AthleteName = "Bram", Season = "Winter", Sport = "Basketball" };

        // Set up the mock to return true when saving
        _mockService.Setup(s => s.ProcessRegistration(vm)).Returns(true);

        // ACT
        var result = _controller.Create(vm) as RedirectToActionResult;

        // ASSERT
        Assert.NotNull(result);
        Assert.Equal("Success", result.ActionName); // Ensure it redirects to the Success page

        // Verify the service was called exactly once with the provided model
        _mockService.Verify(s => s.ProcessRegistration(vm), Times.Once);
    }
}

}

Getting started with C# SOLID Principles

FaithInErrorsZORO — Wed, 30 Sep 2026 02:00:55 +0000

In my repo I've got this `using MusicLab.Projects.Models;
using System.Collections.Generic;
using System.Linq;

namespace MusicLab.Projects.Data
{
public class InstrumentRepository : IInstrumentRepository
{
private readonly MusicDbContext _context;

public InstrumentRepository(MusicDbContext context)
{
    _context = context;
}

public List<Instrument> GetInstruments()
{
    return _context.GetInstruments();
}

public List<Instrument> GetInstrumentsByCategory(string category)
{
    return _context.GetInstruments().Where(i => i.Category == category).ToList();
}

public Instrument FindById(int id)
{
    return _context.FindById(id);
}

public void Add(Instrument i)
{
    _context.Add(i);
}

public void Update(Instrument i)
{
    _context.Update(i);
}

public void Remove(int id)
{
    _context.Remove(id);
}

}
}`

and then in my interface :

C#
using MusicLab.Projects.Models;

namespace MusicLab.Projects.Utils
{
public interface ITaxCalculator
{
decimal CalculateTax(Instrument instrument);
}

public class DefaultTaxCalculator : ITaxCalculator
{
    public decimal CalculateTax(Instrument instrument)
    {
        // Standard tax calculation replacing the static method
        return instrument.Price * 0.15m; 
    }
}

}
and then my csv exporter :

C#
using MusicLab.Projects.Models;
using System.Collections.Generic;
using System.Text;

namespace MusicLab.Projects.Utils
{
public interface ICsvExporter
{
string ExportInstrumentsCsv(List instruments);
}

public class CsvExporter : ICsvExporter
{
    public string ExportInstrumentsCsv(List<Instrument> instruments)
    {
        var sb = new StringBuilder();
        sb.AppendLine("Id,Name,Price,Category");
        foreach (var i in instruments)
        {
            sb.AppendLine($"{i.Id},{i.Name},{i.Price},{i.Category}");
        }
        return sb.ToString();
    }
}

}
and then the controller :

C#
using Microsoft.AspNetCore.Mvc;
using MusicLab.Projects.Data;
using MusicLab.Projects.Models;
using MusicLab.Projects.Utils;
using System.Collections.Generic;
using System.Text;

namespace MusicLab.Projects.Controllers
{
public class InstrumentsController : Controller
{
private readonly IInstrumentRepository _repository;
private readonly ICsvExporter _exporter;
private readonly ITaxCalculator _taxCalculator;

    public InstrumentsController(IInstrumentRepository repository, ICsvExporter exporter, ITaxCalculator taxCalculator)
    {
        _repository = repository;
        _exporter = exporter;
        _taxCalculator = taxCalculator;
    }

    public IActionResult Index(string category)
    {
        List<Instrument> instruments;

        if (!string.IsNullOrWhiteSpace(category))
        {
            instruments = _repository.GetInstrumentsByCategory(category);
        }
        else
        {
            instruments = _repository.GetInstruments();
        }

        return View(instruments);
    }

    public IActionResult Details(int id)
    {
        Instrument instrument = _repository.FindById(id);
        if (instrument == null) return NotFound();

        ViewData["Tax"] = _taxCalculator.CalculateTax(instrument);
        return View(instrument);
    }

    [HttpPost]
    public IActionResult Create(Instrument model)
    {
        if (model == null) return BadRequest("No data");

        // Replaced manual model.IsValid() with built-in ModelState validation
        if (!ModelState.IsValid) return BadRequest("Invalid instrument"); 

        _repository.Add(model);
        return Redirect("/Instruments/Index");
    }

    public IActionResult Export()
    {
        List<Instrument> instruments = _repository.GetInstruments();
        string csv = _exporter.ExportInstrumentsCsv(instruments);
        byte[] bytes = Encoding.UTF8.GetBytes(csv);
        return File(bytes, "text/csv", "instruments.csv");
    }
}

}
and then program.cs :

C#
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using MusicLab.Projects.Data;
using MusicLab.Projects.Utils;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();

// Register the mock DbContext as a Singleton so the list persists in memory
builder.Services.AddSingleton();

// Register dependencies for Dependency Injection
builder.Services.AddScoped();
builder.Services.AddScoped();
builder.Services.AddScoped();

var app = builder.Build();

app.UseRouting();
app.MapControllerRoute(
name: "default",
pattern: "{controller=Instruments}/{action=Index}/{id?}");

app.Run();

Using sessions in asp.net anyone have any insight?

FaithInErrorsZORO — Fri, 17 Apr 2026 03:39:10 +0000

here is how i set it up in program.cs :

builder.Services.AddDistributedMemoryCache();
builder.Services.AddSession(options =>
{
options.IdleTimeout = TimeSpan.FromMinutes(10); // [cite: 16]
options.Cookie.HttpOnly = true;
options.Cookie.IsEssential = true;
});

var app = builder.Build();

[cite_start]// 2. Add Session Middleware (between Routing and Endpoints) [cite: 17]
app.UseRouting();
app.UseSession();
app.UseAuthorization();

here is how i reference the session

[[HttpPost]
public IActionResult Index(string lastName)
{
var player = _context.Players.FirstOrDefault(p => p.LastName == lastName);

if (player == null)
{
    ViewBag.Message = "No player found with that last name.";
    return View();
}

// Store IDs in Session for later use
HttpContext.Session.SetString("playerId", player.PlayerId.ToString());
HttpContext.Session.SetInt32("coachId", player.CoachId ?? 0);
HttpContext.Session.SetInt32("teamId", player.TeamId ?? 0);

return View("Display", player);

}

action to show the stats:

public IActionResult ShowStats()
{
var pId = HttpContext.Session.GetString("playerId");

var playerWithStats = _context.Players
    .Include(p => p.GameRecords)
        .ThenInclude(gr => gr.StatCategory)
    .FirstOrDefault(p => p.PlayerId.ToString() == pId);

return View(playerWithStats);

}

dif types :

public IActionResult ShowCoach()
{
var pId = HttpContext.Session.GetString("playerId");
var cId = HttpContext.Session.GetInt32("coachId");
var tId = HttpContext.Session.GetInt32("teamId");

var player = _context.Players.Find(int.Parse(pId));
var coach = _context.Coaches.Find(cId);
var team = _context.Teams.Find(tId);

// Join class/ViewModel to pass all three objects to the view
var viewModel = new PlayerCoachTeamViewModel { 
    Player = player, 
    Coach = coach, 
    Team = team 
};

return View(viewModel);

}

Making good/ proper line queries in c#?

FaithInErrorsZORO — Wed, 01 Apr 2026 15:49:20 +0000

Query ?:var customerOrdersQuery = (from c in db.Customers
join o in db.Orders on c.CustomerId equals o.CustomerId
select new
{
CustomerName = c.Name,
OrderDate = o.OrderDate
}).ToList();

Method:var customerOrdersMethod = db.Customers
.Join(
db.Orders, // 1. Table to join
c => c.CustomerId, // 2. Key from the first table (Customers)
o => o.CustomerId, // 3. Key from the second table (Orders)
(c, o) => new // 4. The data you want to select
{
CustomerName = c.Name,
OrderDate = o.OrderDate
}
).ToList();

And then to display : @model IEnumerable

@{
ViewData["Title"] = "Full Order Report";
}

<h2>Customer Order Report</h2>

<table>
    <thead>
        <tr>
            <th>Customer Name</th>
            <th>Product Purchased</th>
            <th>Date of Order</th>
        </tr>
    </thead>
    <tbody>
        @* Loop through the joined data stored in the ViewModels *@
        @foreach (var item in Model)
        {
            <tr>
                <td>@item.CustomerName</td>
                <td>@item.ProductName</td>
                <td>@Html.DisplayFor(modelItem =&gt; item.OrderDate)</td>
            </tr>
        }
    </tbody>
</table>

SQL triggers for blocking

FaithInErrorsZORO — Fri, 20 Mar 2026 12:58:26 +0000

AFTER INSERT, UPDATE
AS
BEGIN
SET NOCOUNT ON;

-- Look for the modified InvoiceId in the list of invoices exceeding the limit
IF (SELECT TOP 1 InvoiceId FROM Inserted) IN (
    SELECT InvoiceId
    FROM (
        SELECT IL.InvoiceId, COUNT(*) AS count
        FROM InvoiceLine IL
        JOIN Track T ON IL.TrackId = T.TrackId
        WHERE T.GenreId = 32 --  Genre
        GROUP BY IL.InvoiceId
    ) AS Summary
    WHERE count > 3
)
BEGIN
    RAISERROR ('Market Overload! Max 3 Anime items per invoice.', 16, 1);
    ROLLBACK TRANSACTION;
END

END;