Awesome Blog

Hello blog!

This is a great blog

Test Image:

This document demonstrates the various features of Markdown. You can use this as a reference or a test template.

---

1. Headings

Examples:

Heading 2

Heading 3

Heading 4

Heading 5

Heading 6

---

2. Text Formatting

• Bold: **Bold**
• Italic: *Italic*
• Bold and Italic: ***Bold and Italic***
• ~~Strikethrough~~: ~~Strikethrough~~
• Inline code: `Inline code`

---

3. Lists

Unordered List:

• Item 1
• Sub-item 1
• Sub-item 2
• Item 2

Ordered List:

1. First item
2. Second item
3. Sub-item 1
4. Sub-item 2
5. Third item

---

4. Links and Images

• 

---

5. Blockquotes

This is a blockquote.

It can span multiple lines.

---

6. Tables

| Header 1 | Header 2 | Header 3 |
|----------|----------|----------|
| Row 1 | Data 1 | Data 2 |
| Row 2 | Data 3 | Data 4 |

---

7. Code Blocks

Python Example:

```python
def greet(name):
return f"Hello, {name}!"

print(greet("World"))
```

JavaScript Example:

``javascript // This is a JavaScript code block function greet(name) { returnHello, ${name}!`;
}

console.log(greet("World"));
```

---

8. Horizontal Rules

---

9. Task Lists

• [x] Task 1
• [ ] Task 2
• [ ] Task 3

---

10. Emojis

• :smile: :smile:
• :heart: :heart:
• :rocket: :rocket:

---

11. Escaping Characters

Use a backslash () to escape Markdown characters:

*Literal asterisks*

Great! I've added comprehensive tests for the read_time field functionality. Here's what the tests cover:

Test Coverage:

1. test_read_time_auto_calculation:
   - Verifies the basic calculation works correctly
   - Tests minimum value of 1 minute for short content
   - Tests various word counts (~225, ~450, ~1125 words) to ensure proper calculation

2. test_read_time_updates_on_save:
   - Ensures read_time is recalculated when content changes
   - Tests updating from short to long content and back

3. test_read_time_strips_markdown:
   - Verifies that markdown formatting is properly stripped before counting words
   - Tests various markdown elements: headers, links, bold, italic, code blocks, images, lists, blockquotes
   - Ensures the calculation is based on actual text content, not markdown syntax

4. test_read_time_handles_template_tags:
   - Tests that Django template tags (like the tags mentioned in the model's help text) are handled gracefully
   - Ensures the calculation doesn't break with template syntax

Key Test Features:

• Tests edge cases (minimum value of 1 minute)
• Tests the 225 words-per-minute calculation
• Verifies automatic recalculation on save
• Ensures markdown and template syntax don't inflate the read time
• Uses realistic content patterns that match your actual use case

The tests are designed to be maintainable and clearly document the expected behavior of the read_time feature. They'll help ensure the feature continues to work correctly as your codebase evolves.

Great! I've added comprehensive tests for the read_time field functionality. Here's what the tests cover:

Test Coverage:

1. test_read_time_auto_calculation:
   - Verifies the basic calculation works correctly
   - Tests minimum value of 1 minute for short content
   - Tests various word counts (~225, ~450, ~1125 words) to ensure proper calculation

2. test_read_time_updates_on_save:
   - Ensures read_time is recalculated when content changes
   - Tests updating from short to long content and back

3. test_read_time_strips_markdown:
   - Verifies that markdown formatting is properly stripped before counting words
   - Tests various markdown elements: headers, links, bold, italic, code blocks, images, lists, blockquotes
   - Ensures the calculation is based on actual text content, not markdown syntax

4. test_read_time_handles_template_tags:
   - Tests that Django template tags (like the tags mentioned in the model's help text) are handled gracefully
   - Ensures the calculation doesn't break with template syntax

Key Test Features:

• Tests edge cases (minimum value of 1 minute)
• Tests the 225 words-per-minute calculation
• Verifies automatic recalculation on save
• Ensures markdown and template syntax don't inflate the read time
• Uses realistic content patterns that match your actual use case

The tests are designed to be maintainable and clearly document the expected behavior of the read_time feature. They'll help ensure the feature continues to work correctly as your codebase evolves.

Great! I've added comprehensive tests for the read_time field functionality. Here's what the tests cover:

Test Coverage:

1. test_read_time_auto_calculation:
   - Verifies the basic calculation works correctly
   - Tests minimum value of 1 minute for short content
   - Tests various word counts (~225, ~450, ~1125 words) to ensure proper calculation

2. test_read_time_updates_on_save:
   - Ensures read_time is recalculated when content changes
   - Tests updating from short to long content and back

3. test_read_time_strips_markdown:
   - Verifies that markdown formatting is properly stripped before counting words
   - Tests various markdown elements: headers, links, bold, italic, code blocks, images, lists, blockquotes
   - Ensures the calculation is based on actual text content, not markdown syntax

4. test_read_time_handles_template_tags:
   - Tests that Django template tags (like the tags mentioned in the model's help text) are handled gracefully
   - Ensures the calculation doesn't break with template syntax

Key Test Features:

• Tests edge cases (minimum value of 1 minute)
• Tests the 225 words-per-minute calculation
• Verifies automatic recalculation on save
• Ensures markdown and template syntax don't inflate the read time
• Uses realistic content patterns that match your actual use case

The tests are designed to be maintainable and clearly document the expected behavior of the read_time feature. They'll help ensure the feature continues to work correctly as your codebase evolves.

Great! I've added comprehensive tests for the read_time field functionality. Here's what the tests cover:

Test Coverage:

1. test_read_time_auto_calculation:
   - Verifies the basic calculation works correctly
   - Tests minimum value of 1 minute for short content
   - Tests various word counts (~225, ~450, ~1125 words) to ensure proper calculation

2. test_read_time_updates_on_save:
   - Ensures read_time is recalculated when content changes
   - Tests updating from short to long content and back

3. test_read_time_strips_markdown:
   - Verifies that markdown formatting is properly stripped before counting words
   - Tests various markdown elements: headers, links, bold, italic, code blocks, images, lists, blockquotes
   - Ensures the calculation is based on actual text content, not markdown syntax

4. test_read_time_handles_template_tags:
   - Tests that Django template tags (like the tags mentioned in the model's help text) are handled gracefully
   - Ensures the calculation doesn't break with template syntax

Key Test Features:

• Tests edge cases (minimum value of 1 minute)
• Tests the 225 words-per-minute calculation
• Verifies automatic recalculation on save
• Ensures markdown and template syntax don't inflate the read time
• Uses realistic content patterns that match your actual use case

The tests are designed to be maintainable and clearly document the expected behavior of the read_time feature. They'll help ensure the feature continues to work correctly as your codebase evolves.
Great! I've added comprehensive tests for the read_time field functionality. Here's what the tests cover:

Test Coverage:

1. test_read_time_auto_calculation:
   - Verifies the basic calculation works correctly
   - Tests minimum value of 1 minute for short content
   - Tests various word counts (~225, ~450, ~1125 words) to ensure proper calculation

2. test_read_time_updates_on_save:
   - Ensures read_time is recalculated when content changes
   - Tests updating from short to long content and back

3. test_read_time_strips_markdown:
   - Verifies that markdown formatting is properly stripped before counting words
   - Tests various markdown elements: headers, links, bold, italic, code blocks, images, lists, blockquotes
   - Ensures the calculation is based on actual text content, not markdown syntax

4. test_read_time_handles_template_tags:
   - Tests that Django template tags (like the tags mentioned in the model's help text) are handled gracefully
   - Ensures the calculation doesn't break with template syntax

Key Test Features:

• Tests edge cases (minimum value of 1 minute)
• Tests the 225 words-per-minute calculation
• Verifies automatic recalculation on save
• Ensures markdown and template syntax don't inflate the read time
• Uses realistic content patterns that match your actual use case

The tests are designed to be maintainable and clearly document the expected behavior of the read_time feature. They'll help ensure the feature continues to work correctly as your codebase evolves.
Great! I've added comprehensive tests for the read_time field functionality. Here's what the tests cover:

Test Coverage:

1. test_read_time_auto_calculation:
   - Verifies the basic calculation works correctly
   - Tests minimum value of 1 minute for short content
   - Tests various word counts (~225, ~450, ~1125 words) to ensure proper calculation

2. test_read_time_updates_on_save:
   - Ensures read_time is recalculated when content changes
   - Tests updating from short to long content and back

3. test_read_time_strips_markdown:
   - Verifies that markdown formatting is properly stripped before counting words
   - Tests various markdown elements: headers, links, bold, italic, code blocks, images, lists, blockquotes
   - Ensures the calculation is based on actual text content, not markdown syntax

4. test_read_time_handles_template_tags:
   - Tests that Django template tags (like the tags mentioned in the model's help text) are handled gracefully
   - Ensures the calculation doesn't break with template syntax

Key Test Features:

• Tests edge cases (minimum value of 1 minute)
• Tests the 225 words-per-minute calculation
• Verifies automatic recalculation on save
• Ensures markdown and template syntax don't inflate the read time
• Uses realistic content patterns that match your actual use case

The tests are designed to be maintainable and clearly document the expected behavior of the read_time feature. They'll help ensure the feature continues to work correctly as your codebase evolves.

Great! I've added comprehensive tests for the read_time field functionality. Here's what the tests cover:

Test Coverage:

1. test_read_time_auto_calculation:
   - Verifies the basic calculation works correctly
   - Tests minimum value of 1 minute for short content
   - Tests various word counts (~225, ~450, ~1125 words) to ensure proper calculation

2. test_read_time_updates_on_save:
   - Ensures read_time is recalculated when content changes
   - Tests updating from short to long content and back

3. test_read_time_strips_markdown:
   - Verifies that markdown formatting is properly stripped before counting words
   - Tests various markdown elements: headers, links, bold, italic, code blocks, images, lists, blockquotes
   - Ensures the calculation is based on actual text content, not markdown syntax

4. test_read_time_handles_template_tags:
   - Tests that Django template tags (like the tags mentioned in the model's help text) are handled gracefully
   - Ensures the calculation doesn't break with template syntax

Key Test Features:

• Tests edge cases (minimum value of 1 minute)
• Tests the 225 words-per-minute calculation
• Verifies automatic recalculation on save
• Ensures markdown and template syntax don't inflate the read time
• Uses realistic content patterns that match your actual use case

The tests are designed to be maintainable and clearly document the expected behavior of the read_time feature. They'll help ensure the feature continues to work correctly as your codebase evolves.
Great! I've added comprehensive tests for the read_time field functionality. Here's what the tests cover:

Test Coverage:

1. test_read_time_auto_calculation:
   - Verifies the basic calculation works correctly
   - Tests minimum value of 1 minute for short content
   - Tests various word counts (~225, ~450, ~1125 words) to ensure proper calculation

2. test_read_time_updates_on_save:
   - Ensures read_time is recalculated when content changes
   - Tests updating from short to long content and back

3. test_read_time_strips_markdown:
   - Verifies that markdown formatting is properly stripped before counting words
   - Tests various markdown elements: headers, links, bold, italic, code blocks, images, lists, blockquotes
   - Ensures the calculation is based on actual text content, not markdown syntax

4. test_read_time_handles_template_tags:
   - Tests that Django template tags (like the tags mentioned in the model's help text) are handled gracefully
   - Ensures the calculation doesn't break with template syntax

Key Test Features:

• Tests edge cases (minimum value of 1 minute)
• Tests the 225 words-per-minute calculation
• Verifies automatic recalculation on save
• Ensures markdown and template syntax don't inflate the read time
• Uses realistic content patterns that match your actual use case

The tests are designed to be maintainable and clearly document the expected behavior of the read_time feature. They'll help ensure the feature continues to work correctly as your codebase evolves.
Great! I've added comprehensive tests for the read_time field functionality. Here's what the tests cover:

Test Coverage:

1. test_read_time_auto_calculation:
   - Verifies the basic calculation works correctly
   - Tests minimum value of 1 minute for short content
   - Tests various word counts (~225, ~450, ~1125 words) to ensure proper calculation

2. test_read_time_updates_on_save:
   - Ensures read_time is recalculated when content changes
   - Tests updating from short to long content and back

3. test_read_time_strips_markdown:
   - Verifies that markdown formatting is properly stripped before counting words
   - Tests various markdown elements: headers, links, bold, italic, code blocks, images, lists, blockquotes
   - Ensures the calculation is based on actual text content, not markdown syntax

4. test_read_time_handles_template_tags:
   - Tests that Django template tags (like the tags mentioned in the model's help text) are handled gracefully
   - Ensures the calculation doesn't break with template syntax

Key Test Features:

• Tests edge cases (minimum value of 1 minute)
• Tests the 225 words-per-minute calculation
• Verifies automatic recalculation on save
• Ensures markdown and template syntax don't inflate the read time
• Uses realistic content patterns that match your actual use case

The tests are designed to be maintainable and clearly document the expected behavior of the read_time feature. They'll help ensure the feature continues to work correctly as your codebase evolves.